/* This file is part of Jellyfish.
Jellyfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Jellyfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Jellyfish. If not, see .
*/
#ifndef __JELLYFISH_MAPPED_FILE_HPP__
#define __JELLYFISH_MAPPED_FILE_HPP__
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
class mapped_file {
protected:
std::string _path;
bool _unmap;
char *_base, *_end;
size_t _length;
void map(const char *filename) {
int fd = open(filename, O_RDONLY);
struct stat stat;
if(fd < 0)
eraise(ErrorMMap) << "Can't open file '" << filename << "'" << err::no;
if(fstat(fd, &stat) < 0)
eraise(ErrorMMap) << "Can't stat file '" << filename << "'" << err::no;
_length = stat.st_size;
_base = (char *)mmap(NULL, _length, PROT_READ, MAP_PRIVATE, fd, 0);
if(_base == MAP_FAILED)
eraise(ErrorMMap) << "Can't mmap file '" << filename << "'" << err::no;
close(fd);
_end = _base + _length;
}
public:
define_error_class(ErrorMMap);
mapped_file(char *__base, size_t __length) :
_unmap(false), _base(__base), _end(__base + __length), _length(__length) {}
explicit mapped_file(const char *filename) : _path(filename), _unmap(false) {
map(filename);
}
mapped_file(const mapped_file &mf) :
_path(mf.path()), _unmap(false), _base(mf._base), _end(mf._end),
_length(mf._length) {}
~mapped_file() {
if(_unmap)
unmap();
}
void unmap() {
if(!_base)
return;
munmap(_base, _length);
_base = 0;
_length = 0;
}
char *base() const { return _base; }
char *end() const { return _end; }
size_t length() const { return _length; }
std::string path() const { return _path; }
bool will_unmap(bool value = true) {
bool ovalue = _unmap;
_unmap = value;
return ovalue;
}
// No error checking here. Should I throw something?
const mapped_file & will_need() const {
madvise(_base, _length, MADV_WILLNEED);
return *this;
}
const mapped_file & sequential() const {
madvise(_base, _length, MADV_SEQUENTIAL);
return *this;
}
const mapped_file & random() const {
madvise(_base, _length, MADV_RANDOM);
return *this;
}
const mapped_file & lock() const {
if(mlock(_base, _length) < 0)
eraise(ErrorMMap) << "Can't lock map in memory" << err::no;
return *this;
}
// Do not optimize. Side effect is that every page is accessed and should now be in cache.
// The flagg __attribute__((optimize(0))) does not compile, so return a useless char argument
char load() const;
};
class mapped_files_t : public std::vector {
public:
mapped_files_t(int nb_files, char *argv[]) {
for(int j = 0; j < nb_files; j++)
push_back(mapped_file(argv[j]));
}
mapped_files_t(int nb_files, char *argv[], bool sequential) {
for(int j = 0; j < nb_files; j++) {
push_back(mapped_file(argv[j]));
if(sequential)
end()->sequential();
}
}
};
// File mapped on demand.
class lazy_mapped_file_t : public mapped_file {
std::string _path;
volatile bool done;
volatile long used_counter;
public:
explicit lazy_mapped_file_t(const char *path) :
mapped_file((char *)0, (size_t)0),
_path(path), done(false), used_counter(0) {}
void map() {
used_counter = 1;
done = false;
mapped_file::map(_path.c_str());
}
void unmap() {
done = true;
dec();
}
void inc() {
atomic::gcc::fetch_add(&used_counter, (long)1);
}
void dec() {
long val = atomic::gcc::add_fetch(&used_counter, (long)-1);
if(done && val == 0)
mapped_file::unmap();
}
};
class lazy_mapped_files_t : public std::vector {
public:
lazy_mapped_files_t(int nb_files, char *argv[]) {
for(int j = 0; j < nb_files; j++)
push_back(lazy_mapped_file_t(argv[j]));
}
lazy_mapped_files_t(int nb_files, char *argv[], bool sequential) {
for(int j = 0; j < nb_files; j++) {
push_back(lazy_mapped_file_t(argv[j]));
if(sequential)
end()->sequential();
}
}
};
#endif