# HG changeset patch # User Paul Boddie # Date 1616802905 -3600 # Node ID 497f5b44b489609795b59abfed7788d952e86437 # Parent 3155784fdc96b8bfe055f31a4854e41fd05b5217 Introduced generic page collection and page queue base classes, with distinct page collections and queues supporting files and pipes. diff -r 3155784fdc96 -r 497f5b44b489 Makefile --- a/Makefile Sat Mar 27 00:37:54 2021 +0100 +++ b/Makefile Sat Mar 27 00:55:05 2021 +0100 @@ -55,8 +55,9 @@ access_map.cc accessing.cc accessor.cc \ flexpage.cc file_pager.cc ipc.cc memory.cc \ opener_resource.cc opener_context_resource.cc \ - page_mapper.cc page_queue.cc pager.cc \ - pages.cc pages_conserving.cc paging.cc \ + page_mapper.cc page_queue_partitioned.cc page_queue_shared.cc \ + pager.cc paging.cc \ + page_collection.cc pages.cc pages_conserving.cc \ region.cc resource_server.cc simple_pager.cc PLAIN_SRC_CC_dstest_block_server = \ diff -r 3155784fdc96 -r 497f5b44b489 access_map.cc --- a/access_map.cc Sat Mar 27 00:37:54 2021 +0100 +++ b/access_map.cc Sat Mar 27 00:55:05 2021 +0100 @@ -55,7 +55,7 @@ /* Purge all flexpages, using the 'owner' to flush their contents and 'pages' to make the flexpages available to other accessors. */ -void AccessMap::purge(PageOwner *owner, Pages *pages) +void AccessMap::purge(PageOwner *owner, PageCollection *pages) { std::lock_guard guard(_lock); @@ -84,7 +84,7 @@ /* Flush flexpages in the given range from 'start' with 'size', using 'owner' and 'pages'. */ -void AccessMap::flush_all(offset_t start, offset_t size, PageOwner *owner, Pages *pages) +void AccessMap::flush_all(offset_t start, offset_t size, PageOwner *owner, PageCollection *pages) { offset_t end = start + size; diff -r 3155784fdc96 -r 497f5b44b489 access_map.h --- a/access_map.h Sat Mar 27 00:37:54 2021 +0100 +++ b/access_map.h Sat Mar 27 00:55:05 2021 +0100 @@ -27,9 +27,9 @@ bool remove(PageOwner *owner, Flexpage *flexpage); - void purge(PageOwner *owner, Pages *pages); + void purge(PageOwner *owner, PageCollection *pages); - void flush_all(offset_t start, offset_t size, PageOwner *owner, Pages *pages); + void flush_all(offset_t start, offset_t size, PageOwner *owner, PageCollection *pages); }; // vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 dstest_pipe_server.cc --- a/dstest_pipe_server.cc Sat Mar 27 00:37:54 2021 +0100 +++ b/dstest_pipe_server.cc Sat Mar 27 00:55:05 2021 +0100 @@ -36,7 +36,7 @@ /* Some memory plus infrastructure. */ Memory mem(MEMORY_PAGES); - PipeOpenerResource opener; + PipeOpenerResource opener(&mem); /* Register a server associating it with the given object. */ @@ -53,3 +53,5 @@ server.start(); return 0; } + +// vim: tabstop=2 expandtab shiftwidth=2 diff -r 3155784fdc96 -r 497f5b44b489 files/pipe_paging.cc --- a/files/pipe_paging.cc Sat Mar 27 00:37:54 2021 +0100 +++ b/files/pipe_paging.cc Sat Mar 27 00:55:05 2021 +0100 @@ -1,8 +1,16 @@ #include "pipe_paging.h" +PipePaging::PipePaging(Memory *memory, offset_t size) +: _memory(NULL), _size(size) +{ + _pages = new PagesConserving(memory); +} + PipePaging::PipePaging(offset_t size) : _size(size) { + _memory = new Memory(); + _pages = new PagesConserving(_memory); } /* Detach one endpoint. */ @@ -29,6 +37,13 @@ mapper->detach(); delete mapper; } + + /* Delete the page collection and memory object. */ + + delete _pages; + + if (_memory != NULL) + delete _memory; } /* Add a region to the sequence. */ diff -r 3155784fdc96 -r 497f5b44b489 files/pipe_paging.h --- a/files/pipe_paging.h Sat Mar 27 00:37:54 2021 +0100 +++ b/files/pipe_paging.h Sat Mar 27 00:55:05 2021 +0100 @@ -12,7 +12,8 @@ class PipePaging { protected: - PagesConserving _pages; + Memory *_memory; + PagesConserving *_pages; /* Regions acting as files with their own accessors. */ @@ -28,12 +29,14 @@ unsigned int _endpoints = 2; public: + explicit PipePaging(Memory *memory, offset_t size); + explicit PipePaging(offset_t size); virtual void detach(); virtual PagesConserving *pages() - { return &_pages; } + { return _pages; } virtual offset_t region_size() { return _size; } diff -r 3155784fdc96 -r 497f5b44b489 page_collection.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/page_collection.cc Sat Mar 27 00:55:05 2021 +0100 @@ -0,0 +1,64 @@ +#include "pages.h" + +PageCollection::PageCollection(Memory *memory) +: _memory(memory) +{ +} + +PageCollection::PageCollection() +{ + _memory = new Memory(); +} + +/* Remove the first flexpage in the queue. If its owner exists, remove it from + the owner (retiring the content). Return the flexpage for reuse. */ + +Flexpage *PageCollection::remove() +{ + PageOwner *owner; + Flexpage *flexpage; + + _queue->pop(&owner, &flexpage); + + if (owner != NULL) + owner->remove(flexpage); + + return flexpage; +} + +/* Reserve 'flexpage' by removing it from this collection. */ + +bool PageCollection::reserve(PageOwner *owner, Flexpage *flexpage) +{ + return _queue->remove(owner, flexpage); +} + +/* Obtain a new flexpage. Return the flexpage or None if no new flexpage could + be created. */ + +Flexpage *PageCollection::flexpage() +{ + Region *region = _memory->region(); + + if (region != NULL) + return new Flexpage(region); + else + return NULL; +} + +/* Queue an entry associating the given 'owner' and 'flexpage'. */ + +void PageCollection::queue(PageOwner *owner, Flexpage *flexpage) +{ + _queue->push(owner, flexpage); +} + +/* Push an entry for 'flexpage' without owner association for immediate + reuse. */ + +void PageCollection::release(Flexpage *flexpage) +{ + _queue->push_front(NULL, flexpage); +} + +// vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 page_collection.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/page_collection.h Sat Mar 27 00:55:05 2021 +0100 @@ -0,0 +1,38 @@ +#pragma once + +#include "flexpage.h" +#include "memory.h" +#include "page_owner.h" +#include "page_queue.h" + + + +/* A page collection. */ + +class PageCollection +{ +protected: + PageQueue *_queue; + Memory *_memory; + +public: + explicit PageCollection(Memory *memory); + + explicit PageCollection(); + + virtual ~PageCollection() + { + } + + virtual Flexpage *remove(); + + virtual bool reserve(PageOwner *owner, Flexpage *flexpage); + + virtual Flexpage *flexpage(); + + virtual void queue(PageOwner *owner, Flexpage *flexpage); + + virtual void release(Flexpage *flexpage); +}; + +// vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 page_mapper.cc --- a/page_mapper.cc Sat Mar 27 00:37:54 2021 +0100 +++ b/page_mapper.cc Sat Mar 27 00:55:05 2021 +0100 @@ -3,7 +3,7 @@ -PageMapper::PageMapper(Accessor *accessor, Pages *pages) +PageMapper::PageMapper(Accessor *accessor, PageCollection *pages) : _accessor(accessor), _pages(pages), _attached(0) { } diff -r 3155784fdc96 -r 497f5b44b489 page_mapper.h --- a/page_mapper.h Sat Mar 27 00:37:54 2021 +0100 +++ b/page_mapper.h Sat Mar 27 00:55:05 2021 +0100 @@ -13,7 +13,7 @@ protected: AccessMap _map; Accessor *_accessor; - Pages *_pages; + PageCollection *_pages; unsigned int _attached; std::mutex _lock; @@ -24,7 +24,7 @@ Flexpage *flexpage(offset_t offset); public: - explicit PageMapper(Accessor *accessor, Pages *pages); + explicit PageMapper(Accessor *accessor, PageCollection *pages); /* Accounting methods. */ diff -r 3155784fdc96 -r 497f5b44b489 page_queue.cc --- a/page_queue.cc Sat Mar 27 00:37:54 2021 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,101 +0,0 @@ -#include "page_queue.h" - -/* Keep waiting for a potential queue non-empty condition. - Then, attempt to pop an entry from the queue. */ - -void PageQueue::pop(PageOwner **owner, Flexpage **flexpage) -{ - std::unique_lock guard(_lock); - QueueEntry entry; - - while (1) - { - if (_pop(&entry)) - { - *owner = entry.owner; - *flexpage = entry.flexpage; - return; - } - else - _counter.wait(guard); - } -} - -/* Check the queue for entries, returning false if no entries are available, - returning true and providing the details if an entry can be removed from the - front of the queue. */ - -bool PageQueue::_pop(QueueEntry *entry) -{ - if (_queue.empty()) - return false; - - *entry = _queue.front(); - _queue.pop_front(); - - /* Remove any position reference for the flexpage. */ - - Positions::iterator position = _positions.find(entry->flexpage); - - if (position != _positions.end()) - _positions.erase(position); - - return true; -} - -/* Push an entry for the given owner and flexpage to the queue. */ - -void PageQueue::push(PageOwner *owner, Flexpage *flexpage) -{ - std::lock_guard guard(_lock); - - /* Record the entry and a position reference for the flexpage. */ - - _queue.push_back((QueueEntry) {flexpage, owner}); - - Queue::iterator last = _queue.end(); - last--; - _positions.insert(Position(flexpage, last)); - - _counter.notify_one(); -} - -/* Push an entry to the front of the queue. */ - -void PageQueue::push_front(PageOwner *owner, Flexpage *flexpage) -{ - std::lock_guard guard(_lock); - - _queue.push_back((QueueEntry) {flexpage, owner}); - _positions.insert(Position(flexpage, _queue.begin())); - - _counter.notify_one(); -} - -/* Remove an entry for the given owner and flexpage from the queue. */ - -bool PageQueue::remove(PageOwner *owner, Flexpage *flexpage) -{ - std::lock_guard guard(_lock); - - Positions::iterator position = _positions.find(flexpage); - - if (position == _positions.end()) - return false; - - /* The found owner may be different from the requesting owner or even NULL - if another owner has acquired and then purged its pages. Such a purged - flexpage is not immediately usable, however. */ - - Queue::iterator entry = position->second; - - if ((entry->owner == NULL) || (entry->owner != owner)) - return false; - - _queue.erase(entry); - _positions.erase(position); - - return true; -} - -// vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 page_queue.h --- a/page_queue.h Sat Mar 27 00:37:54 2021 +0100 +++ b/page_queue.h Sat Mar 27 00:55:05 2021 +0100 @@ -1,9 +1,7 @@ #pragma once -#include #include #include -#include #include "flexpage.h" #include "page_owner.h" @@ -20,27 +18,18 @@ -/* A queue of issued pages. */ +/* A queue of managed pages. */ class PageQueue { -protected: - Queue _queue; - Positions _positions; - - std::mutex _lock; - std::condition_variable _counter; - - bool _pop(QueueEntry *entry); +public: + virtual void pop(PageOwner **owner, Flexpage **flexpage) = 0; -public: - void pop(PageOwner **owner, Flexpage **flexpage); + virtual void push(PageOwner *owner, Flexpage *flexpage) = 0; - void push(PageOwner *owner, Flexpage *flexpage); + virtual void push_front(PageOwner *owner, Flexpage *flexpage) = 0; - void push_front(PageOwner *owner, Flexpage *flexpage); - - bool remove(PageOwner *owner, Flexpage *flexpage); + virtual bool remove(PageOwner *owner, Flexpage *flexpage) = 0; }; // vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 page_queue_partitioned.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/page_queue_partitioned.cc Sat Mar 27 00:55:05 2021 +0100 @@ -0,0 +1,103 @@ +#include "page_queue_partitioned.h" + +/* Keep waiting for a potential queue non-empty condition. + Then, attempt to pop an entry from the queue. */ + +void PageQueuePartitioned::pop(PageOwner **owner, Flexpage **flexpage) +{ + std::unique_lock guard(_lock); + QueueEntry entry; + + while (1) + { + if (_pop(&entry)) + { + *owner = entry.owner; + *flexpage = entry.flexpage; + return; + } + else + _counter.wait(guard); + } +} + +/* Check the available pages queue for entries, returning false if no entries + are available, returning true and providing the details if an entry can be + removed from the front of the queue. */ + +bool PageQueuePartitioned::_pop(QueueEntry *entry) +{ + if (_available.empty()) + return false; + + *entry = _available.front(); + _available.pop_front(); + + return true; +} + +/* Push an entry for the given owner and flexpage to the appropriate queue. */ + +void PageQueuePartitioned::push(PageOwner *owner, Flexpage *flexpage) +{ + std::lock_guard guard(_lock); + + /* Record the entry and a position reference for the flexpage. */ + + Queue *queue; + Positions *positions = NULL; + + if (owner == NULL) + queue = &_available; + else + { + queue = &_issued; + positions = &_positions; + } + + queue->push_back((QueueEntry) {flexpage, owner}); + + if (positions != NULL) + { + Queue::iterator last = queue->end(); + last--; + positions->insert(Position(flexpage, last)); + } + + _counter.notify_one(); +} + +/* Push an entry to the front of the appropriate queue. */ + +void PageQueuePartitioned::push_front(PageOwner *owner, Flexpage *flexpage) +{ + std::lock_guard guard(_lock); + + Queue *queue; + Positions *positions = NULL; + + if (owner == NULL) + queue = &_available; + else + { + queue = &_issued; + positions = &_positions; + } + + queue->push_back((QueueEntry) {flexpage, owner}); + + if (positions != NULL) + positions->insert(Position(flexpage, queue->begin())); + + _counter.notify_one(); +} + +/* Remove an entry for the given owner and flexpage from the queue. */ + +bool PageQueuePartitioned::remove(PageOwner *owner, Flexpage *flexpage) +{ + (void) owner; (void) flexpage; + return true; +} + +// vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 page_queue_partitioned.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/page_queue_partitioned.h Sat Mar 27 00:55:05 2021 +0100 @@ -0,0 +1,33 @@ +#pragma once + +#include +#include + +#include "page_queue.h" + + + +/* Queues of issued and available pages. */ + +class PageQueuePartitioned : public PageQueue +{ +protected: + Queue _issued, _available; + Positions _positions; + + std::mutex _lock; + std::condition_variable _counter; + + virtual bool _pop(QueueEntry *entry); + +public: + virtual void pop(PageOwner **owner, Flexpage **flexpage); + + virtual void push(PageOwner *owner, Flexpage *flexpage); + + virtual void push_front(PageOwner *owner, Flexpage *flexpage); + + virtual bool remove(PageOwner *owner, Flexpage *flexpage); +}; + +// vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 page_queue_shared.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/page_queue_shared.cc Sat Mar 27 00:55:05 2021 +0100 @@ -0,0 +1,101 @@ +#include "page_queue_shared.h" + +/* Keep waiting for a potential queue non-empty condition. + Then, attempt to pop an entry from the queue. */ + +void PageQueueShared::pop(PageOwner **owner, Flexpage **flexpage) +{ + std::unique_lock guard(_lock); + QueueEntry entry; + + while (1) + { + if (_pop(&entry)) + { + *owner = entry.owner; + *flexpage = entry.flexpage; + return; + } + else + _counter.wait(guard); + } +} + +/* Check the queue for entries, returning false if no entries are available, + returning true and providing the details if an entry can be removed from the + front of the queue. */ + +bool PageQueueShared::_pop(QueueEntry *entry) +{ + if (_queue.empty()) + return false; + + *entry = _queue.front(); + _queue.pop_front(); + + /* Remove any position reference for the flexpage. */ + + Positions::iterator position = _positions.find(entry->flexpage); + + if (position != _positions.end()) + _positions.erase(position); + + return true; +} + +/* Push an entry for the given owner and flexpage to the queue. */ + +void PageQueueShared::push(PageOwner *owner, Flexpage *flexpage) +{ + std::lock_guard guard(_lock); + + /* Record the entry and a position reference for the flexpage. */ + + _queue.push_back((QueueEntry) {flexpage, owner}); + + Queue::iterator last = _queue.end(); + last--; + _positions.insert(Position(flexpage, last)); + + _counter.notify_one(); +} + +/* Push an entry to the front of the queue. */ + +void PageQueueShared::push_front(PageOwner *owner, Flexpage *flexpage) +{ + std::lock_guard guard(_lock); + + _queue.push_back((QueueEntry) {flexpage, owner}); + _positions.insert(Position(flexpage, _queue.begin())); + + _counter.notify_one(); +} + +/* Remove an entry for the given owner and flexpage from the queue. */ + +bool PageQueueShared::remove(PageOwner *owner, Flexpage *flexpage) +{ + std::lock_guard guard(_lock); + + Positions::iterator position = _positions.find(flexpage); + + if (position == _positions.end()) + return false; + + /* The found owner may be different from the requesting owner or even NULL + if another owner has acquired and then purged its pages. Such a purged + flexpage is not immediately usable, however. */ + + Queue::iterator entry = position->second; + + if ((entry->owner == NULL) || (entry->owner != owner)) + return false; + + _queue.erase(entry); + _positions.erase(position); + + return true; +} + +// vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 page_queue_shared.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/page_queue_shared.h Sat Mar 27 00:55:05 2021 +0100 @@ -0,0 +1,33 @@ +#pragma once + +#include +#include + +#include "page_queue.h" + + + +/* A queue of issued pages. */ + +class PageQueueShared : public PageQueue +{ +protected: + Queue _queue; + Positions _positions; + + std::mutex _lock; + std::condition_variable _counter; + + virtual bool _pop(QueueEntry *entry); + +public: + virtual void pop(PageOwner **owner, Flexpage **flexpage); + + virtual void push(PageOwner *owner, Flexpage *flexpage); + + virtual void push_front(PageOwner *owner, Flexpage *flexpage); + + virtual bool remove(PageOwner *owner, Flexpage *flexpage); +}; + +// vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 pages.cc --- a/pages.cc Sat Mar 27 00:37:54 2021 +0100 +++ b/pages.cc Sat Mar 27 00:55:05 2021 +0100 @@ -1,64 +1,15 @@ #include "pages.h" Pages::Pages(Memory *memory) -: _memory(memory) +: PageCollection(memory) { + _queue = &_page_queue; } Pages::Pages() -{ - _memory = new Memory(); -} - -/* Remove the first flexpage in the queue. If its owner exists, remove it from - the owner (retiring the content). Return the flexpage for reuse. */ - -Flexpage *Pages::remove() -{ - PageOwner *owner; - Flexpage *flexpage; - - _queue.pop(&owner, &flexpage); - - if (owner != NULL) - owner->remove(flexpage); - - return flexpage; -} - -/* Reserve 'flexpage' by removing it from this collection. */ - -bool Pages::reserve(PageOwner *owner, Flexpage *flexpage) +: PageCollection() { - return _queue.remove(owner, flexpage); -} - -/* Obtain a new flexpage. Return the flexpage or None if no new flexpage could - be created. */ - -Flexpage *Pages::flexpage() -{ - Region *region = _memory->region(); - - if (region != NULL) - return new Flexpage(region); - else - return NULL; -} - -/* Queue an entry associating the given 'owner' and 'flexpage'. */ - -void Pages::queue(PageOwner *owner, Flexpage *flexpage) -{ - _queue.push(owner, flexpage); -} - -/* Push an entry for 'flexpage' without owner association for immediate - reuse. */ - -void Pages::release(Flexpage *flexpage) -{ - _queue.push_front(NULL, flexpage); + _queue = &_page_queue; } // vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 pages.h --- a/pages.h Sat Mar 27 00:37:54 2021 +0100 +++ b/pages.h Sat Mar 27 00:55:05 2021 +0100 @@ -1,34 +1,21 @@ #pragma once -#include "flexpage.h" -#include "memory.h" -#include "page_owner.h" -#include "page_queue.h" +#include "page_collection.h" +#include "page_queue_shared.h" /* A page collection. */ -class Pages +class Pages : public PageCollection { protected: - PageQueue _queue; - Memory *_memory; + PageQueueShared _page_queue; public: explicit Pages(Memory *memory); explicit Pages(); - - virtual Flexpage *remove(); - - virtual bool reserve(PageOwner *owner, Flexpage *flexpage); - - virtual Flexpage *flexpage(); - - virtual void queue(PageOwner *owner, Flexpage *flexpage); - - virtual void release(Flexpage *flexpage); }; // vim: tabstop=4 expandtab shiftwidth=4 diff -r 3155784fdc96 -r 497f5b44b489 pages_conserving.cc --- a/pages_conserving.cc Sat Mar 27 00:37:54 2021 +0100 +++ b/pages_conserving.cc Sat Mar 27 00:55:05 2021 +0100 @@ -1,13 +1,15 @@ #include "pages_conserving.h" PagesConserving::PagesConserving(Memory *memory) -: Pages(memory) +: PageCollection(memory) { + _queue = &_page_queue; } PagesConserving::PagesConserving() -: Pages() +: PageCollection() { + _queue = &_page_queue; } @@ -20,24 +22,6 @@ return NULL; } -/* Pretend to queue an entry associating the given 'owner' and 'flexpage'. - Since this collection "conserves" flexpages, they will not be queued unless - completely unused. */ - -void PagesConserving::queue(PageOwner *owner, Flexpage *flexpage) -{ - (void) owner; (void) flexpage; -} - -/* Pretend to reserve a flexpage already being used by 'owner' and 'flexpage'. - Since flexpages are not queued when in use, there is nothing to reserve. */ - -bool PagesConserving::reserve(PageOwner *owner, Flexpage *flexpage) -{ - (void) owner; (void) flexpage; - return true; -} - /* Decrease the provision of flexpages to pipes. */ @@ -83,7 +67,7 @@ /* Queue flexpages for the regions. */ for (it = allocated.begin(); it != allocated.end(); it++) - _queue.push(NULL, new Flexpage(*it)); + _queue->push(NULL, new Flexpage(*it)); return true; } diff -r 3155784fdc96 -r 497f5b44b489 pages_conserving.h --- a/pages_conserving.h Sat Mar 27 00:37:54 2021 +0100 +++ b/pages_conserving.h Sat Mar 27 00:55:05 2021 +0100 @@ -1,14 +1,18 @@ #pragma once -#include "pages.h" +#include "page_collection.h" +#include "page_queue_partitioned.h" /* A page collection where the pages are "conserved", meaning that they are not queued for reuse unless they are completely unused. */ -class PagesConserving : public Pages +class PagesConserving : public PageCollection { +protected: + PageQueuePartitioned _page_queue; + public: explicit PagesConserving(Memory *memory); @@ -18,10 +22,6 @@ virtual Flexpage *flexpage(); - virtual void queue(PageOwner *owner, Flexpage *flexpage); - - virtual bool reserve(PageOwner *owner, Flexpage *flexpage); - /* Memory control methods. */ virtual bool decrease(offset_t size); diff -r 3155784fdc96 -r 497f5b44b489 pipe_opener_resource.cc --- a/pipe_opener_resource.cc Sat Mar 27 00:37:54 2021 +0100 +++ b/pipe_opener_resource.cc Sat Mar 27 00:55:05 2021 +0100 @@ -7,8 +7,14 @@ /* Support for providing access to pipes. */ +PipeOpenerResource::PipeOpenerResource(Memory *memory) +: _memory(memory) +{ +} + PipeOpenerResource::PipeOpenerResource() { + _memory = new Memory(); } int PipeOpenerResource::expected_items() @@ -29,7 +35,7 @@ { /* Both endpoints will employ a common paging coordinator. */ - PipePaging *paging = new PipePaging(size); + PipePaging *paging = new PipePaging(_memory, size); /* Each endpoint will have its own pager. */ diff -r 3155784fdc96 -r 497f5b44b489 pipe_opener_resource.h --- a/pipe_opener_resource.h Sat Mar 27 00:37:54 2021 +0100 +++ b/pipe_opener_resource.h Sat Mar 27 00:55:05 2021 +0100 @@ -1,5 +1,6 @@ #pragma once +#include "memory.h" #include "pipe_opener_interface.h" #include "pipe_paging.h" #include "resource.h" @@ -9,9 +10,13 @@ class PipeOpenerResource : public Resource, public PipeOpener { protected: + Memory *_memory; + long open_endpoint(PipePaging *paging, bool writing, l4_cap_idx_t *endpoint); public: + explicit PipeOpenerResource(Memory *memory); + explicit PipeOpenerResource(); /* Server details. */