Plexi09/eden-miror
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden synced 2026-05-13 00:08:39 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

[fs] use mmap() to read files off the mmap system for higher throughput

Browse source 
Signed-off-by: lizzie <lizzie@eden-emu.dev>
This commit is contained in:
lizzie 2025-12-06 03:09:05 +00:00 • committed by crueter
parent a7ef19e028
commit 856f9a64a1
2 changed files with 181 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

273
src/common/fs/file.cpp
View file

@ -19,6 +19,9 @@
#include <share.h> #include <share.h>
#else #else
#include <unistd.h> #include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#endif #endif
#ifdef _MSC_VER #ifdef _MSC_VER
@ -246,13 +249,10 @@ FileType IOFile::GetType() const {
void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) { void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
Close(); Close();
file_path = path; file_path = path;
file_access_mode = mode; file_access_mode = mode;
file_type = type; file_type = type;
errno = 0; errno = 0;
#ifdef _WIN32 #ifdef _WIN32
if (flag != FileShareFlag::ShareNone) { if (flag != FileShareFlag::ShareNone) {
file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag)); file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
@ -262,51 +262,63 @@ void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, File
#elif ANDROID #elif ANDROID
if (Android::IsContentUri(path)) { if (Android::IsContentUri(path)) {
ASSERT_MSG(mode == FileAccessMode::Read, "Content URI file access is for read-only!"); ASSERT_MSG(mode == FileAccessMode::Read, "Content URI file access is for read-only!");
const auto fd = Android::OpenContentUri(path, Android::OpenMode::Read); auto const fd = Android::OpenContentUri(path, Android::OpenMode::Read);
if (fd != -1) { if (fd != -1) {
file = fdopen(fd, "r"); file = fdopen(fd, "r");
const auto error_num = errno; if (errno != 0 && file == nullptr)
if (error_num != 0 && file == nullptr) { LOG_ERROR(Common_Filesystem, "Error opening file: {}, error: {}", path.c_str(), strerror(errno));
LOG_ERROR(Common_Filesystem, "Error opening file: {}, error: {}", path.c_str(),
strerror(error_num));
}
} else { } else {
LOG_ERROR(Common_Filesystem, "Error opening file: {}", path.c_str()); LOG_ERROR(Common_Filesystem, "Error opening file: {}", path.c_str());
} }
} else { } else {
file = std::fopen(path.c_str(), AccessModeToStr(mode, type)); file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
} }
#elif defined(__unix__) && !defined(__HAIKU__) && !defined(__managarm__)
if (type == FileType::BinaryFile && mode == FileAccessMode::Read) {
struct stat st;
mmap_fd = open(path.c_str(), O_RDONLY);
fstat(mmap_fd, &st);
mmap_size = st.st_size;
mmap_base = (u8*)mmap(nullptr, mmap_size, PROT_READ, MAP_PRIVATE, mmap_fd, 0);
} else {
file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
}
#else #else
file = std::fopen(path.c_str(), AccessModeToStr(mode, type)); file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
#endif #endif
if (!IsOpen()) { if (!IsOpen()) {
const auto ec = std::error_code{errno, std::generic_category()}; const auto ec = std::error_code{errno, std::generic_category()};
LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}, ec_message={}", LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}, ec_message={}",
PathToUTF8String(file_path), ec.message()); PathToUTF8String(file_path), ec.message());
} }
} }
void IOFile::Close() { void IOFile::Close() {
if (!IsOpen()) { #ifdef __unix__
return; if (mmap_fd != -1) {
munmap(mmap_base, mmap_size);
close(mmap_fd);
mmap_fd = -1;
} }
#endif
errno = 0; if (file) {
errno = 0;
const auto close_result = std::fclose(file) == 0; const auto close_result = std::fclose(file) == 0;
if (!close_result) {
if (!close_result) { const auto ec = std::error_code{errno, std::generic_category()};
const auto ec = std::error_code{errno, std::generic_category()}; LOG_ERROR(Common_Filesystem, "Failed to close the file at path={}, ec_message={}",
LOG_ERROR(Common_Filesystem, "Failed to close the file at path={}, ec_message={}", PathToUTF8String(file_path), ec.message());
PathToUTF8String(file_path), ec.message()); }
file = nullptr;
} }
file = nullptr;
} }
bool IOFile::IsOpen() const { bool IOFile::IsOpen() const {
#ifdef __unix__
return file != nullptr || mmap_fd != -1;
#else
return file != nullptr; return file != nullptr;
#endif
} }
std::string IOFile::ReadString(size_t length) const { std::string IOFile::ReadString(size_t length) const {
@ -323,137 +335,148 @@ size_t IOFile::WriteString(std::span<const char> string) const {
} }
bool IOFile::Flush() const { bool IOFile::Flush() const {
if (!IsOpen()) { #ifdef __unix__
return false; ASSERT(mmap_fd == -1);
}
errno = 0;
#ifdef _WIN32
const auto flush_result = std::fflush(file) == 0;
#else
const auto flush_result = std::fflush(file) == 0;
#endif #endif
if (file) {
if (!flush_result) { errno = 0;
const auto ec = std::error_code{errno, std::generic_category()}; #ifdef _WIN32
LOG_ERROR(Common_Filesystem, "Failed to flush the file at path={}, ec_message={}", const auto flush_result = std::fflush(file) == 0;
PathToUTF8String(file_path), ec.message()); #else
const auto flush_result = std::fflush(file) == 0;
#endif
if (!flush_result) {
const auto ec = std::error_code{errno, std::generic_category()};
LOG_ERROR(Common_Filesystem, "Failed to flush the file at path={}, ec_message={}",
PathToUTF8String(file_path), ec.message());
}
return flush_result;
} }
return false;
return flush_result;
} }
bool IOFile::Commit() const { bool IOFile::Commit() const {
if (!IsOpen()) { #ifdef __unix__
return false; ASSERT(mmap_fd == -1);
}
errno = 0;
#ifdef _WIN32
const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
#else
const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
#endif #endif
if (file) {
if (!commit_result) { errno = 0;
const auto ec = std::error_code{errno, std::generic_category()}; #ifdef _WIN32
LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}", const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
PathToUTF8String(file_path), ec.message()); #else
const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
#endif
if (!commit_result) {
const auto ec = std::error_code{errno, std::generic_category()};
LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}",
PathToUTF8String(file_path), ec.message());
}
return commit_result;
} }
return false;
return commit_result;
} }
bool IOFile::SetSize(u64 size) const { bool IOFile::SetSize(u64 size) const {
if (!IsOpen()) { #ifdef __unix__
return false; ASSERT(mmap_fd == -1);
}
errno = 0;
#ifdef _WIN32
const auto set_size_result = _chsize_s(fileno(file), static_cast<s64>(size)) == 0;
#else
const auto set_size_result = ftruncate(fileno(file), static_cast<s64>(size)) == 0;
#endif #endif
if (file) {
if (!set_size_result) { errno = 0;
const auto ec = std::error_code{errno, std::generic_category()}; #ifdef _WIN32
LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}", const auto set_size_result = _chsize_s(fileno(file), s64(size)) == 0;
PathToUTF8String(file_path), size, ec.message()); #else
const auto set_size_result = ftruncate(fileno(file), s64(size)) == 0;
#endif
if (!set_size_result) {
const auto ec = std::error_code{errno, std::generic_category()};
LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}",
PathToUTF8String(file_path), size, ec.message());
}
return set_size_result;
} }
return false;
return set_size_result;
} }
u64 IOFile::GetSize() const { u64 IOFile::GetSize() const {
if (!IsOpen()) { #ifdef __unix__
return 0; if (mmap_fd != -1)
} return mmap_size;
#endif
// Flush any unwritten buffered data into the file prior to retrieving the file size. if (file) {
std::fflush(file); // Flush any unwritten buffered data into the file prior to retrieving the file mmap_size.
std::fflush(file);
#if ANDROID #if ANDROID
u64 file_size = 0; u64 file_size = 0;
if (Android::IsContentUri(file_path)) { if (Android::IsContentUri(file_path)) {
file_size = Android::GetSize(file_path); file_size = Android::GetSize(file_path);
} else { } else {
std::error_code ec;
file_size = fs::file_size(file_path, ec);
if (ec) {
LOG_ERROR(Common_Filesystem, "Failed to retrieve the file mmap_size of path={}, ec_message={}",
PathToUTF8String(file_path), ec.message());
return 0;
}
}
#else
std::error_code ec; std::error_code ec;
auto const file_size = fs::file_size(file_path, ec);
file_size = fs::file_size(file_path, ec);
if (ec) { if (ec) {
LOG_ERROR(Common_Filesystem, LOG_ERROR(Common_Filesystem, "Failed to retrieve the file mmap_size of path={}, ec_message={}",
"Failed to retrieve the file size of path={}, ec_message={}", PathToUTF8String(file_path), ec.message());
PathToUTF8String(file_path), ec.message());
return 0; return 0;
} }
}
#else
std::error_code ec;
const auto file_size = fs::file_size(file_path, ec);
if (ec) {
LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
PathToUTF8String(file_path), ec.message());
return 0;
}
#endif #endif
return file_size;
return file_size; }
return 0;
} }
bool IOFile::Seek(s64 offset, SeekOrigin origin) const { bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
if (!IsOpen()) { #ifdef __unix__
return false; if (mmap_fd != -1) {
// fuck you to whoever made this method const
switch (origin) {
case SeekOrigin::SetOrigin:
mmap_offset = off_t(offset);
break;
case SeekOrigin::CurrentPosition:
mmap_offset += off_t(offset);
break;
case SeekOrigin::End:
mmap_offset = off_t(mmap_size) + off_t(offset);
break;
}
return true;
} }
#endif
errno = 0; if (file) {
errno = 0;
const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0; const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
if (!seek_result) {
if (!seek_result) { const auto ec = std::error_code{errno, std::generic_category()};
const auto ec = std::error_code{errno, std::generic_category()}; LOG_ERROR(Common_Filesystem, "Failed to seek the file at path={}, offset={}, origin={}, ec_message={}",
LOG_ERROR(Common_Filesystem, PathToUTF8String(file_path), offset, origin, ec.message());
"Failed to seek the file at path={}, offset={}, origin={}, ec_message={}", }
PathToUTF8String(file_path), offset, origin, ec.message()); return seek_result;
} }
return false;
return seek_result;
} }
s64 IOFile::Tell() const { s64 IOFile::Tell() const {
if (!IsOpen()) { #ifdef __unix__
return 0; if (mmap_fd != -1) {
errno = 0;
return s64(mmap_offset);
} }
#endif
errno = 0; if (file) {
errno = 0;
return ftello(file); return ftello(file);
}
return 0;
} }
} // namespace Common::FS } // namespace Common::FS

71
src/common/fs/file.h
View file

@ -183,19 +183,6 @@ public:
FileType type = FileType::BinaryFile, FileType type = FileType::BinaryFile,
FileShareFlag flag = FileShareFlag::ShareReadOnly); FileShareFlag flag = FileShareFlag::ShareReadOnly);
// #ifdef _WIN32
// template <typename Path>
// void Open(const Path& path, FileAccessMode mode, FileType type = FileType::BinaryFile,
// FileShareFlag flag = FileShareFlag::ShareReadOnly) {
// using ValueType = typename Path::value_type;
// if constexpr (IsChar<ValueType>) {
// Open(ToU8String(path), mode, type, flag);
// } else {
// Open(std::filesystem::path{path}, mode, type, flag);
// }
// }
// #endif
/// Closes the file if it is opened. /// Closes the file if it is opened.
void Close(); void Close();
@ -225,8 +212,7 @@ public:
[[nodiscard]] size_t Read(T& data) const { [[nodiscard]] size_t Read(T& data) const {
if constexpr (IsContiguousContainer<T>) { if constexpr (IsContiguousContainer<T>) {
using ContiguousType = typename T::value_type; using ContiguousType = typename T::value_type;
static_assert(std::is_trivially_copyable_v<ContiguousType>, static_assert(std::is_trivially_copyable_v<ContiguousType>, "Data type must be trivially copyable.");
"Data type must be trivially copyable.");
return ReadSpan<ContiguousType>(data); return ReadSpan<ContiguousType>(data);
} else { } else {
return ReadObject(data) ? 1 : 0; return ReadObject(data) ? 1 : 0;
@ -251,8 +237,7 @@ public:
[[nodiscard]] size_t Write(const T& data) const { [[nodiscard]] size_t Write(const T& data) const {
if constexpr (IsContiguousContainer<T>) { if constexpr (IsContiguousContainer<T>) {
using ContiguousType = typename T::value_type; using ContiguousType = typename T::value_type;
static_assert(std::is_trivially_copyable_v<ContiguousType>, static_assert(std::is_trivially_copyable_v<ContiguousType>, "Data type must be trivially copyable.");
"Data type must be trivially copyable.");
return WriteSpan<ContiguousType>(data); return WriteSpan<ContiguousType>(data);
} else { } else {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
@ -279,12 +264,13 @@ public:
template <typename T> template <typename T>
[[nodiscard]] size_t ReadSpan(std::span<T> data) const { [[nodiscard]] size_t ReadSpan(std::span<T> data) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
#ifdef __unix__
if (!IsOpen()) { if (mmap_fd != -1) {
return 0; std::memcpy(data.data(), mmap_base + mmap_offset, sizeof(T) * data.size());
return data.size();
} }
#endif
return std::fread(data.data(), sizeof(T), data.size(), file); return IsOpen() ? std::fread(data.data(), sizeof(T), data.size(), file) : 0;
} }
/** /**
@ -305,12 +291,13 @@ public:
template <typename T> template <typename T>
[[nodiscard]] size_t WriteSpan(std::span<const T> data) const { [[nodiscard]] size_t WriteSpan(std::span<const T> data) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
#ifdef __unix__
if (!IsOpen()) { if (mmap_fd != -1) {
return 0; std::memcpy(mmap_base + mmap_offset, data.data(), sizeof(T) * data.size());
return data.size();
} }
#endif
return std::fwrite(data.data(), sizeof(T), data.size(), file); return IsOpen() ? std::fwrite(data.data(), sizeof(T), data.size(), file) : 0;
} }
/** /**
@ -333,12 +320,13 @@ public:
[[nodiscard]] bool ReadObject(T& object) const { [[nodiscard]] bool ReadObject(T& object) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object."); static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
#ifdef __unix__
if (!IsOpen()) { if (mmap_fd != -1) {
return false; std::memcpy(&object, mmap_base + mmap_offset, sizeof(T));
return sizeof(T);
} }
#endif
return std::fread(&object, sizeof(T), 1, file) == 1; return IsOpen() ? std::fread(&object, sizeof(T), 1, file) == 1 : false;
} }
/** /**
@ -360,12 +348,13 @@ public:
[[nodiscard]] bool WriteObject(const T& object) const { [[nodiscard]] bool WriteObject(const T& object) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object."); static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
#ifdef __unix__
if (!IsOpen()) { if (mmap_fd != -1) {
return false; std::memcpy(mmap_base + mmap_offset, &object, sizeof(T));
return sizeof(T);
} }
#endif
return std::fwrite(&object, sizeof(T), 1, file) == 1; return IsOpen() ? std::fwrite(&object, sizeof(T), 1, file) == 1 : false;
} }
/** /**
@ -452,8 +441,14 @@ private:
std::filesystem::path file_path; std::filesystem::path file_path;
FileAccessMode file_access_mode{}; FileAccessMode file_access_mode{};
FileType file_type{}; FileType file_type{};
std::FILE* file = nullptr; std::FILE* file = nullptr;
#ifdef __unix__
int mmap_fd = -1;
u8* mmap_base = nullptr;
size_t mmap_size = 0;
// fuck you
mutable off_t mmap_offset = 0;
#endif
}; };
} // namespace Common::FS } // namespace Common::FS