Reorder declarations

Author: extratype

service.hpp

@@ -69,6 +69,8 @@ struct PageEntry
 
 class PageLock : public SRWLockBase<PageLock>
 {
+    PageEntry* entry_;
+
 public:
     PageLock() : SRWLockBase(), entry_(nullptr) {}
 
@@ -90,9 +92,6 @@ class PageLock : public SRWLockBase<PageLock>
     {
         if (is_exclusive) entry_->clear_owner();
     }
-
-private:
-    PageEntry* entry_;
 };
 
 // operation result, only for current thread
@@ -108,6 +107,26 @@ struct PageResult
 
 class ChunkDiskService
 {
+    std::vector<FileHandle> part_lock_;             // part index -> .lock
+
+    std::unique_ptr<std::shared_mutex> mutex_parts_;
+    std::vector<u64> part_current_;                 // part index -> # of chunks
+    size_t part_current_new_ = 0;                   // part index for new chunks
+    std::unordered_map<u64, size_t> chunk_parts_;   // chunk index -> part index
+
+    std::unique_ptr<std::shared_mutex> mutex_pages_;
+    // BLOCK_SIZE -> PAGE_SIZE access
+    // read cache, write through
+    // add to back, evict from front
+    Map<u64, PageEntry> cached_pages_;
+
+    std::unique_ptr<std::shared_mutex> mutex_unmapped_;
+    // chunk index -> [start_off, end_off)
+    std::unordered_map<u64, std::map<u64, u64>> chunk_unmapped_;
+
+    // not movable
+    std::atomic<u64> post_ft_ = 0;
+
 public:
     const ChunkDiskParams params;
 
@@ -184,26 +203,6 @@ class ChunkDiskService
     void SetPostFileTime(u64 ft) { post_ft_.store(ft, std::memory_order_release); }
 
 private:
-    std::vector<FileHandle> part_lock_;             // part index -> .lock
-
-    std::unique_ptr<std::shared_mutex> mutex_parts_;
-    std::vector<u64> part_current_;                 // part index -> # of chunks
-    size_t part_current_new_ = 0;                   // part index for new chunks
-    std::unordered_map<u64, size_t> chunk_parts_;   // chunk index -> part index
-
-    std::unique_ptr<std::shared_mutex> mutex_pages_;
-    // BLOCK_SIZE -> PAGE_SIZE access
-    // read cache, write through
-    // add to back, evict from front
-    Map<u64, PageEntry> cached_pages_;
-
-    std::unique_ptr<std::shared_mutex> mutex_unmapped_;
-    // chunk index -> [start_off, end_off)
-    std::unordered_map<u64, std::map<u64, u64>> chunk_unmapped_;
-
-    // not movable
-    std::atomic<u64> post_ft_ = 0;
-
     // lk: mutex_pages_, shared
     // it: from cached_pages_ while holding lk
     // return ERROR_LOCK_FAILED if it is locked by the current thread

types.hpp

@@ -47,17 +47,27 @@ struct pair_hash
 template <class KT, class VT>
 class Map
 {
-public:
     struct VIt
     {
         VT val;
         typename std::list<const KT*>::iterator it; // iterator in key_order_
     };
 
+    std::unordered_map<KT, VIt> map_;
+    std::list<const KT*> key_order_;
+
+public:
     // iterate in the insertion order
     // invalidated if invalidated in map_
-    struct iterator
+    class iterator
     {
+        friend class Map;
+
+        std::unordered_map<KT, VIt>* map_ = nullptr;
+        typename std::unordered_map<KT, VIt>::iterator it_;
+        typename std::list<const KT*>::iterator end_it_;    // key_order_.end()
+
+    public:
         iterator() = default;
 
         explicit iterator(std::unordered_map<KT, VIt>* map,
@@ -83,13 +93,6 @@ class Map
         {
             return map_ == other.map_ && it_ == other.it_ && end_it_ == other.end_it_;
         }
-
-    private:
-        friend class Map;
-
-        std::unordered_map<KT, VIt>* map_ = nullptr;
-        typename std::unordered_map<KT, VIt>::iterator it_;
-        typename std::list<const KT*>::iterator end_it_;    // key_order_.end()
     };
 
     auto front() { return *find(*key_order_.front()); }
@@ -189,10 +192,6 @@ class Map
     }
 
     void reserve(size_t count) { map_.reserve(count); }
-
-private:
-    std::unordered_map<KT, VIt> map_;
-    std::list<const KT*> key_order_;
 };
 
 }

utils.hpp

@@ -23,6 +23,9 @@ namespace chunkdisk
 template <class Derived>
 class SRWLockBase
 {
+    std::unique_lock<std::shared_mutex> ulock_;
+    std::shared_lock<std::shared_mutex> slock_;
+
 public:
     SRWLockBase() = default;
 
@@ -176,10 +179,6 @@ class SRWLockBase
     void on_locked(bool is_exclusive);
 
     void on_unlock(bool is_exclusive);
-
-private:
-    std::unique_lock<std::shared_mutex> ulock_;
-    std::shared_lock<std::shared_mutex> slock_;
 };
 
 class SRWLock : public SRWLockBase<SRWLock>

worker.hpp

@@ -111,6 +111,29 @@ struct ChunkFileHandle
 // can't be shared with other dispatchers
 class ChunkDiskWorker
 {
+    enum IOCPKey
+    {
+        CK_IO = 0,      // completed file I/O
+        CK_POST,        // disk I/O request from PostWork()
+        CK_STOP         // cancel pending I/O ops and stop DoWorks()
+    };
+
+    ChunkDiskService& service_;
+    std::thread thread_;
+    GenericHandle iocp_;
+    GenericHandle wait_event_;
+    GenericHandle spd_ovl_event_;
+    OVERLAPPED spd_ovl_ = {};
+
+    std::unique_ptr<std::shared_mutex> mutex_working_;
+    std::list<ChunkWork> working_;
+
+    std::unique_ptr<std::shared_mutex> mutex_buffers_;
+    std::deque<Pages> buffers_;
+
+    std::unique_ptr<std::shared_mutex> mutex_handles_;
+    Map<u64, ChunkFileHandle> chunk_handles_;   // add to back, evict from front
+
 public:
     explicit ChunkDiskWorker(ChunkDiskService& service) : service_(service) {}
 
@@ -158,29 +181,6 @@ class ChunkDiskWorker
     DWORD PostWork(SPD_STORAGE_UNIT_OPERATION_CONTEXT* context, ChunkOpKind op_kind, u64 block_addr, u32 count);
 
 private:
-    enum IOCPKey
-    {
-        CK_IO = 0,      // completed file I/O
-        CK_POST,        // disk I/O request from PostWork()
-        CK_STOP         // cancel pending I/O ops and stop DoWorks()
-    };
-
-    ChunkDiskService& service_;
-    std::thread thread_;
-    GenericHandle iocp_;
-    GenericHandle wait_event_;
-    GenericHandle spd_ovl_event_;
-    OVERLAPPED spd_ovl_ = {};
-
-    std::unique_ptr<std::shared_mutex> mutex_working_;
-    std::list<ChunkWork> working_;
-
-    std::unique_ptr<std::shared_mutex> mutex_buffers_;
-    std::deque<Pages> buffers_;
-
-    std::unique_ptr<std::shared_mutex> mutex_handles_;
-    Map<u64, ChunkFileHandle> chunk_handles_;   // add to back, evict from front
-
     // get zero-filled, page aligned buffer from the pool
     DWORD GetBuffer(Pages& buffer);