MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-11-25 16:22:35 +01:00
Code Issues Releases Wiki Activity

ircd::ctx::shared_state_base: Add assertions; comments; minor cleanup.

Browse source
This commit is contained in:
Jason Volk 2019-09-08 13:02:32 -07:00
parent 7cc029d726
commit 5b2216fb63
3 changed files with 21 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
include/ircd/ctx/promise.h
View file

@ -43,12 +43,12 @@ namespace ircd::ctx
/// other party, and a pointer to the next instance of their own party.
struct ircd::ctx::promise_base
{
// Internal operations
static const promise_base *head(const shared_state_base &);
static const promise_base *head(const promise_base &);
static size_t refcount(const shared_state_base &);
static promise_base *head(shared_state_base &);
static promise_base *head(promise_base &);
static size_t refcount(const shared_state_base &);
shared_state_base *st {nullptr}; // the head of all sharing futures
promise_base *next {nullptr}; // next sharing promise
@ -67,7 +67,7 @@ struct ircd::ctx::promise_base
bool operator!() const noexcept;
explicit operator bool() const noexcept;
void set_exception(std::exception_ptr eptr);
void set_exception(std::exception_ptr);
protected:
promise_base() = default;

4
include/ircd/ctx/shared_state.h
View file

@ -57,7 +57,9 @@ enum class ircd::ctx::future_state
/// dereference the promise pointer (head promise) and follow the st->next
/// list. The only way to traverse the list of promises is to dereference a
/// shared_state_base with a valid *p in future_state::PENDING and chase the
/// p->next list.
/// p->next list. Each side of the system relies on the other. This means any
/// proper iteration of the promise or future lists can only take place before
/// dissolution of the system.
struct ircd::ctx::shared_state_base
{
static const shared_state_base *head(const shared_state_base &);

22
ircd/ctx.cc
View file

@ -2127,8 +2127,7 @@ ircd::ctx::remove(promise_base &p)
else
invalidate_futures(p);
}
if(last)
else if(last)
for(auto *next{last->next}; next; last = next, next = next->next)
if(next == &p)
{
@ -2155,7 +2154,7 @@ ircd::ctx::update(promise_base &new_,
if(last == &old)
set_futures_promise(new_);
if(last)
else if(last)
for(auto *next{last->next}; next; last = next, next = last->next)
if(next == &old)
{
@ -2174,6 +2173,7 @@ ircd::ctx::append(promise_base &new_,
promise_base &old)
{
assert(new_.st);
assert(old.st);
if(!old.next)
{
old.next = &new_;
@ -2196,8 +2196,10 @@ ircd::ctx::set_futures_promise(promise_base &p)
};
for(; next; next = next->next)
if(is(*next, future_state::PENDING))
next->p = std::addressof(p);
{
assert(is(*next, future_state::PENDING));
next->p = std::addressof(p);
}
}
void
@ -2209,8 +2211,10 @@ ircd::ctx::invalidate_futures(promise_base &p)
};
for(; next; next = next->next)
if(is(*next, future_state::PENDING))
next->p = nullptr;
{
assert(is(*next, future_state::PENDING));
next->p = nullptr;
}
}
///////////////////////////////////////////////////////////////////////////////
@ -2353,6 +2357,9 @@ ircd::ctx::shared_state_base::operator=(promise_base &p)
{
this->~shared_state_base();
new (this) shared_state_base{p};
assert(p.valid());
assert(is(*this, future_state::PENDING));
return *this;
}
@ -2480,6 +2487,7 @@ ircd::ctx::remove(shared_state_base &st)
shared_state_base::head(st)
};
assert(last);
if(last == &st && is(st, future_state::PENDING))
{
if(last->next)