From 87a92ef062dcfca44e6122dea6cad747daaa2659 Mon Sep 17 00:00:00 2001 From: Lioncash Date: Thu, 26 Apr 2018 14:57:38 -0400 Subject: common: Remove chunk_file.h and linear_disk_cache.h These are unused (and given chunk_file references Dolphin's >SVN< I doubt they were going to be used). --- src/common/CMakeLists.txt | 2 - src/common/chunk_file.h | 623 ----------------------------------------- src/common/linear_disk_cache.h | 167 ----------- 3 files changed, 792 deletions(-) delete mode 100644 src/common/chunk_file.h delete mode 100644 src/common/linear_disk_cache.h diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt index 32cb85de0..f49a31612 100644 --- a/src/common/CMakeLists.txt +++ b/src/common/CMakeLists.txt @@ -31,7 +31,6 @@ add_library(common STATIC bit_set.h break_points.cpp break_points.h - chunk_file.h cityhash.cpp cityhash.h color.h @@ -41,7 +40,6 @@ add_library(common STATIC file_util.cpp file_util.h hash.h - linear_disk_cache.h logging/backend.cpp logging/backend.h logging/filter.cpp diff --git a/src/common/chunk_file.h b/src/common/chunk_file.h deleted file mode 100644 index 972ef9039..000000000 --- a/src/common/chunk_file.h +++ /dev/null @@ -1,623 +0,0 @@ -// Copyright (C) 2003 Dolphin Project. - -// This program 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, version 2.0 or later versions. - -// This program 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 2.0 for more details. - -// A copy of the GPL 2.0 should have been included with the program. -// If not, see http://www.gnu.org/licenses/ - -// Official SVN repository and contact information can be found at -// http://code.google.com/p/dolphin-emu/ - -#pragma once - -// Extremely simple serialization framework. - -// (mis)-features: -// + Super fast -// + Very simple -// + Same code is used for serialization and deserializaition (in most cases) -// - Zero backwards/forwards compatibility -// - Serialization code for anything complex has to be manually written. - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "common/assert.h" -#include "common/common_types.h" -#include "common/logging/log.h" - -template -struct LinkedListItem : public T { - LinkedListItem* next; -}; - -class PointerWrap; - -class PointerWrapSection { -public: - PointerWrapSection(PointerWrap& p, int ver, const char* title) - : p_(p), ver_(ver), title_(title) {} - ~PointerWrapSection(); - - bool operator==(const int& v) const { - return ver_ == v; - } - bool operator!=(const int& v) const { - return ver_ != v; - } - bool operator<=(const int& v) const { - return ver_ <= v; - } - bool operator>=(const int& v) const { - return ver_ >= v; - } - bool operator<(const int& v) const { - return ver_ < v; - } - bool operator>(const int& v) const { - return ver_ > v; - } - - operator bool() const { - return ver_ > 0; - } - -private: - PointerWrap& p_; - int ver_; - const char* title_; -}; - -// Wrapper class -class PointerWrap { -// This makes it a compile error if you forget to define DoState() on non-POD. -// Which also can be a problem, for example struct tm is non-POD on linux, for whatever reason... -#ifdef _MSC_VER - template ::value, - bool isPointer = std::is_pointer::value> -#else - template ::value> -#endif - struct DoHelper { - static void DoArray(PointerWrap* p, T* x, int count) { - for (int i = 0; i < count; ++i) - p->Do(x[i]); - } - - static void Do(PointerWrap* p, T& x) { - p->DoClass(x); - } - }; - - template - struct DoHelper { - static void DoArray(PointerWrap* p, T* x, int count) { - p->DoVoid((void*)x, sizeof(T) * count); - } - - static void Do(PointerWrap* p, T& x) { - p->DoVoid((void*)&x, sizeof(x)); - } - }; - -public: - enum Mode { - MODE_READ = 1, // load - MODE_WRITE, // save - MODE_MEASURE, // calculate size - MODE_VERIFY, // compare - }; - - enum Error { - ERROR_NONE = 0, - ERROR_WARNING = 1, - ERROR_FAILURE = 2, - }; - - u8** ptr; - Mode mode; - Error error; - -public: - PointerWrap(u8** ptr_, Mode mode_) : ptr(ptr_), mode(mode_), error(ERROR_NONE) {} - PointerWrap(unsigned char** ptr_, int mode_) - : ptr((u8**)ptr_), mode((Mode)mode_), error(ERROR_NONE) {} - - PointerWrapSection Section(const char* title, int ver) { - return Section(title, ver, ver); - } - - // The returned object can be compared against the version that was loaded. - // This can be used to support versions as old as minVer. - // Version = 0 means the section was not found. - PointerWrapSection Section(const char* title, int minVer, int ver) { - char marker[16] = {0}; - int foundVersion = ver; - - strncpy(marker, title, sizeof(marker)); - if (!ExpectVoid(marker, sizeof(marker))) { - // Might be before we added name markers for safety. - if (foundVersion == 1 && ExpectVoid(&foundVersion, sizeof(foundVersion))) - DoMarker(title); - // Wasn't found, but maybe we can still load the state. - else - foundVersion = 0; - } else - Do(foundVersion); - - if (error == ERROR_FAILURE || foundVersion < minVer || foundVersion > ver) { - LOG_ERROR(Common, "Savestate failure: wrong version %d found for %s", foundVersion, - title); - SetError(ERROR_FAILURE); - return PointerWrapSection(*this, -1, title); - } - return PointerWrapSection(*this, foundVersion, title); - } - - void SetMode(Mode mode_) { - mode = mode_; - } - Mode GetMode() const { - return mode; - } - u8** GetPPtr() { - return ptr; - } - void SetError(Error error_) { - if (error < error_) - error = error_; - if (error > ERROR_WARNING) - mode = PointerWrap::MODE_MEASURE; - } - - bool ExpectVoid(void* data, int size) { - switch (mode) { - case MODE_READ: - if (memcmp(data, *ptr, size) != 0) - return false; - break; - case MODE_WRITE: - memcpy(*ptr, data, size); - break; - case MODE_MEASURE: - break; // MODE_MEASURE - don't need to do anything - case MODE_VERIFY: - for (int i = 0; i < size; i++) { - DEBUG_ASSERT_MSG( - ((u8*)data)[i] == (*ptr)[i], - "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", - ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i], - &(*ptr)[i]); - } - break; - default: - break; // throw an error? - } - (*ptr) += size; - return true; - } - - void DoVoid(void* data, int size) { - switch (mode) { - case MODE_READ: - memcpy(data, *ptr, size); - break; - case MODE_WRITE: - memcpy(*ptr, data, size); - break; - case MODE_MEASURE: - break; // MODE_MEASURE - don't need to do anything - case MODE_VERIFY: - for (int i = 0; i < size; i++) { - DEBUG_ASSERT_MSG( - ((u8*)data)[i] == (*ptr)[i], - "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", - ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i], - &(*ptr)[i]); - } - break; - default: - break; // throw an error? - } - (*ptr) += size; - } - - template - void Do(std::map& x) { - if (mode == MODE_READ) { - for (auto it = x.begin(), end = x.end(); it != end; ++it) { - if (it->second != nullptr) - delete it->second; - } - } - T* dv = nullptr; - DoMap(x, dv); - } - - template - void Do(std::map& x) { - T dv = T(); - DoMap(x, dv); - } - - template - void DoMap(std::map& x, T& default_val) { - unsigned int number = (unsigned int)x.size(); - Do(number); - switch (mode) { - case MODE_READ: { - x.clear(); - while (number > 0) { - K first = K(); - Do(first); - T second = default_val; - Do(second); - x[first] = second; - --number; - } - } break; - case MODE_WRITE: - case MODE_MEASURE: - case MODE_VERIFY: { - typename std::map::iterator itr = x.begin(); - while (number > 0) { - K first = itr->first; - Do(first); - Do(itr->second); - --number; - ++itr; - } - } break; - } - } - - template - void Do(std::multimap& x) { - if (mode == MODE_READ) { - for (auto it = x.begin(), end = x.end(); it != end; ++it) { - if (it->second != nullptr) - delete it->second; - } - } - T* dv = nullptr; - DoMultimap(x, dv); - } - - template - void Do(std::multimap& x) { - T dv = T(); - DoMultimap(x, dv); - } - - template - void DoMultimap(std::multimap& x, T& default_val) { - unsigned int number = (unsigned int)x.size(); - Do(number); - switch (mode) { - case MODE_READ: { - x.clear(); - while (number > 0) { - K first = K(); - Do(first); - T second = default_val; - Do(second); - x.insert(std::make_pair(first, second)); - --number; - } - } break; - case MODE_WRITE: - case MODE_MEASURE: - case MODE_VERIFY: { - typename std::multimap::iterator itr = x.begin(); - while (number > 0) { - Do(itr->first); - Do(itr->second); - --number; - ++itr; - } - } break; - } - } - - // Store vectors. - template - void Do(std::vector& x) { - T* dv = nullptr; - DoVector(x, dv); - } - - template - void Do(std::vector& x) { - T dv = T(); - DoVector(x, dv); - } - - template - void DoPOD(std::vector& x) { - T dv = T(); - DoVectorPOD(x, dv); - } - - template - void Do(std::vector& x, T& default_val) { - DoVector(x, default_val); - } - - template - void DoVector(std::vector& x, T& default_val) { - u32 vec_size = (u32)x.size(); - Do(vec_size); - x.resize(vec_size, default_val); - if (vec_size > 0) - DoArray(&x[0], vec_size); - } - - template - void DoVectorPOD(std::vector& x, T& default_val) { - u32 vec_size = (u32)x.size(); - Do(vec_size); - x.resize(vec_size, default_val); - if (vec_size > 0) - DoArray(&x[0], vec_size); - } - - // Store deques. - template - void Do(std::deque& x) { - T* dv = nullptr; - DoDeque(x, dv); - } - - template - void Do(std::deque& x) { - T dv = T(); - DoDeque(x, dv); - } - - template - void DoDeque(std::deque& x, T& default_val) { - u32 deq_size = (u32)x.size(); - Do(deq_size); - x.resize(deq_size, default_val); - u32 i; - for (i = 0; i < deq_size; i++) - Do(x[i]); - } - - // Store STL lists. - template - void Do(std::list& x) { - T* dv = nullptr; - Do(x, dv); - } - - template - void Do(std::list& x) { - T dv = T(); - DoList(x, dv); - } - - template - void Do(std::list& x, T& default_val) { - DoList(x, default_val); - } - - template - void DoList(std::list& x, T& default_val) { - u32 list_size = (u32)x.size(); - Do(list_size); - x.resize(list_size, default_val); - - typename std::list::iterator itr, end; - for (itr = x.begin(), end = x.end(); itr != end; ++itr) - Do(*itr); - } - - // Store STL sets. - template - void Do(std::set& x) { - if (mode == MODE_READ) { - for (auto it = x.begin(), end = x.end(); it != end; ++it) { - if (*it != nullptr) - delete *it; - } - } - DoSet(x); - } - - template - void Do(std::set& x) { - DoSet(x); - } - - template - void DoSet(std::set& x) { - unsigned int number = (unsigned int)x.size(); - Do(number); - - switch (mode) { - case MODE_READ: { - x.clear(); - while (number-- > 0) { - T it = T(); - Do(it); - x.insert(it); - } - } break; - case MODE_WRITE: - case MODE_MEASURE: - case MODE_VERIFY: { - typename std::set::iterator itr = x.begin(); - while (number-- > 0) - Do(*itr++); - } break; - - default: - LOG_ERROR(Common, "Savestate error: invalid mode %d.", mode); - } - } - - // Store strings. - void Do(std::string& x) { - int stringLen = (int)x.length() + 1; - Do(stringLen); - - switch (mode) { - case MODE_READ: - x = (char*)*ptr; - break; - case MODE_WRITE: - memcpy(*ptr, x.c_str(), stringLen); - break; - case MODE_MEASURE: - break; - case MODE_VERIFY: - DEBUG_ASSERT_MSG((x == (char*)*ptr), - "Savestate verification failure: \"%s\" != \"%s\" (at %p).\n", - x.c_str(), (char*)*ptr, ptr); - break; - } - (*ptr) += stringLen; - } - - void Do(std::wstring& x) { - int stringLen = sizeof(wchar_t) * ((int)x.length() + 1); - Do(stringLen); - - switch (mode) { - case MODE_READ: - x = (wchar_t*)*ptr; - break; - case MODE_WRITE: - memcpy(*ptr, x.c_str(), stringLen); - break; - case MODE_MEASURE: - break; - case MODE_VERIFY: - DEBUG_ASSERT_MSG((x == (wchar_t*)*ptr), - "Savestate verification failure: \"%ls\" != \"%ls\" (at %p).\n", - x.c_str(), (wchar_t*)*ptr, ptr); - break; - } - (*ptr) += stringLen; - } - - template - void DoClass(T& x) { - x.DoState(*this); - } - - template - void DoClass(T*& x) { - if (mode == MODE_READ) { - if (x != nullptr) - delete x; - x = new T(); - } - x->DoState(*this); - } - - template - void DoArray(T* x, int count) { - DoHelper::DoArray(this, x, count); - } - - template - void Do(T& x) { - DoHelper::Do(this, x); - } - - template - void DoPOD(T& x) { - DoHelper::Do(this, x); - } - - template - void DoPointer(T*& x, T* const base) { - // pointers can be more than 2^31 apart, but you're using this function wrong if you need - // that much range - s32 offset = x - base; - Do(offset); - if (mode == MODE_READ) - x = base + offset; - } - - template * (*TNew)(), void (*TFree)(LinkedListItem*), - void (*TDo)(PointerWrap&, T*)> - void DoLinkedList(LinkedListItem*& list_start, LinkedListItem** list_end = nullptr) { - LinkedListItem* list_cur = list_start; - LinkedListItem* prev = nullptr; - - while (true) { - u8 shouldExist = (list_cur ? 1 : 0); - Do(shouldExist); - if (shouldExist == 1) { - LinkedListItem* cur = list_cur ? list_cur : TNew(); - TDo(*this, (T*)cur); - if (!list_cur) { - if (mode == MODE_READ) { - cur->next = nullptr; - list_cur = cur; - if (prev) - prev->next = cur; - else - list_start = cur; - } else { - TFree(cur); - continue; - } - } - } else { - if (mode == MODE_READ) { - if (prev) - prev->next = nullptr; - if (list_end) - *list_end = prev; - if (list_cur) { - if (list_start == list_cur) - list_start = nullptr; - do { - LinkedListItem* next = list_cur->next; - TFree(list_cur); - list_cur = next; - } while (list_cur); - } - } - break; - } - prev = list_cur; - list_cur = list_cur->next; - } - } - - void DoMarker(const char* prevName, u32 arbitraryNumber = 0x42) { - u32 cookie = arbitraryNumber; - Do(cookie); - if (mode == PointerWrap::MODE_READ && cookie != arbitraryNumber) { - LOG_ERROR(Common, - "After \"%s\", found %d (0x%X) instead of save marker %d (0x%X). " - "Aborting savestate load...", - prevName, cookie, cookie, arbitraryNumber, arbitraryNumber); - SetError(ERROR_FAILURE); - } - } -}; - -inline PointerWrapSection::~PointerWrapSection() { - if (ver_ > 0) { - p_.DoMarker(title_); - } -} diff --git a/src/common/linear_disk_cache.h b/src/common/linear_disk_cache.h deleted file mode 100644 index 94c695163..000000000 --- a/src/common/linear_disk_cache.h +++ /dev/null @@ -1,167 +0,0 @@ -// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#pragma once - -#include -#include "common/common_types.h" - -// defined in Version.cpp -extern const char* scm_rev_git_str; - -// On disk format: -// header{ -// u32 'DCAC'; -// u32 version; // svn_rev -// u16 sizeof(key_type); -// u16 sizeof(value_type); -//} - -// key_value_pair{ -// u32 value_size; -// key_type key; -// value_type[value_size] value; -//} - -template -class LinearDiskCacheReader { -public: - virtual void Read(const K& key, const V* value, u32 value_size) = 0; -}; - -// Dead simple unsorted key-value store with append functionality. -// No random read functionality, all reading is done in OpenAndRead. -// Keys and values can contain any characters, including \0. -// -// Suitable for caching generated shader bytecode between executions. -// Not tuned for extreme performance but should be reasonably fast. -// Does not support keys or values larger than 2GB, which should be reasonable. -// Keys must have non-zero length; values can have zero length. - -// K and V are some POD type -// K : the key type -// V : value array type -template -class LinearDiskCache { -public: - // return number of read entries - u32 OpenAndRead(const char* filename, LinearDiskCacheReader& reader) { - using std::ios_base; - - // close any currently opened file - Close(); - m_num_entries = 0; - - // try opening for reading/writing - OpenFStream(m_file, filename, ios_base::in | ios_base::out | ios_base::binary); - - m_file.seekg(0, std::ios::end); - std::fstream::pos_type end_pos = m_file.tellg(); - m_file.seekg(0, std::ios::beg); - std::fstream::pos_type start_pos = m_file.tellg(); - std::streamoff file_size = end_pos - start_pos; - - if (m_file.is_open() && ValidateHeader()) { - // good header, read some key/value pairs - K key; - - V* value = nullptr; - u32 value_size; - u32 entry_number; - - std::fstream::pos_type last_pos = m_file.tellg(); - - while (Read(&value_size)) { - std::streamoff next_extent = - (last_pos - start_pos) + sizeof(value_size) + value_size; - if (next_extent > file_size) - break; - - delete[] value; - value = new V[value_size]; - - // read key/value and pass to reader - if (Read(&key) && Read(value, value_size) && Read(&entry_number) && - entry_number == m_num_entries + 1) { - reader.Read(key, value, value_size); - } else { - break; - } - - m_num_entries++; - last_pos = m_file.tellg(); - } - m_file.seekp(last_pos); - m_file.clear(); - - delete[] value; - return m_num_entries; - } - - // failed to open file for reading or bad header - // close and recreate file - Close(); - m_file.open(filename, ios_base::out | ios_base::trunc | ios_base::binary); - WriteHeader(); - return 0; - } - - void Sync() { - m_file.flush(); - } - - void Close() { - if (m_file.is_open()) - m_file.close(); - // clear any error flags - m_file.clear(); - } - - // Appends a key-value pair to the store. - void Append(const K& key, const V* value, u32 value_size) { - // TODO: Should do a check that we don't already have "key"? (I think each caller does that - // already.) - Write(&value_size); - Write(&key); - Write(value, value_size); - m_num_entries++; - Write(&m_num_entries); - } - -private: - void WriteHeader() { - Write(&m_header); - } - - bool ValidateHeader() { - char file_header[sizeof(Header)]; - - return (Read(file_header, sizeof(Header)) && - !memcmp((const char*)&m_header, file_header, sizeof(Header))); - } - - template - bool Write(const D* data, u32 count = 1) { - return m_file.write((const char*)data, count * sizeof(D)).good(); - } - - template - bool Read(const D* data, u32 count = 1) { - return m_file.read((char*)data, count * sizeof(D)).good(); - } - - struct Header { - Header() : id(*(u32*)"DCAC"), key_t_size(sizeof(K)), value_t_size(sizeof(V)) { - memcpy(ver, scm_rev_git_str, 40); - } - - const u32 id; - const u16 key_t_size, value_t_size; - char ver[40]; - - } m_header; - - std::fstream m_file; - u32 m_num_entries; -}; -- cgit v1.2.3