Skip to content

Commit

Permalink
Split nano::scheduler::bucket in to its own class and file
Browse files Browse the repository at this point in the history
  • Loading branch information
clemahieu committed Sep 8, 2023
1 parent 6d47d24 commit 3480bfb
Show file tree
Hide file tree
Showing 5 changed files with 137 additions and 44 deletions.
2 changes: 2 additions & 0 deletions nano/node/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -194,6 +194,8 @@ add_library(
rocksdb/rocksdb_iterator.hpp
rocksdb/rocksdb_txn.hpp
rocksdb/rocksdb_txn.cpp
scheduler/bucket.cpp
scheduler/bucket.hpp
scheduler/buckets.cpp
scheduler/buckets.hpp
scheduler/component.hpp
Expand Down
67 changes: 67 additions & 0 deletions nano/node/scheduler/bucket.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,67 @@
#include <nano/lib/blocks.hpp>
#include <nano/node/scheduler/bucket.hpp>

bool nano::scheduler::bucket::value_type::operator< (value_type const & other_a) const
{
return time < other_a.time || (time == other_a.time && block->hash () < other_a.block->hash ());
}

bool nano::scheduler::bucket::value_type::operator== (value_type const & other_a) const
{
return time == other_a.time && block->hash () == other_a.block->hash ();
}

nano::scheduler::bucket::bucket (size_t maximum) :
maximum{ maximum }
{
debug_assert (maximum > 0);
}

nano::scheduler::bucket::~bucket ()
{
}

bool nano::scheduler::bucket::available () const
{
return !queue.empty ();
}

std::shared_ptr<nano::block> nano::scheduler::bucket::top () const
{
debug_assert (!queue.empty ());
return queue.begin ()->block;
}

void nano::scheduler::bucket::pop ()
{
debug_assert (!queue.empty ());
queue.erase (queue.begin ());
}

void nano::scheduler::bucket::push (uint64_t time, std::shared_ptr<nano::block> block)
{
queue.insert ({ time, block });
if (queue.size () > maximum)
{
debug_assert (!queue.empty ());
queue.erase (--queue.end ());
}
}

size_t nano::scheduler::bucket::size () const
{
return queue.size ();
}

bool nano::scheduler::bucket::empty () const
{
return queue.empty ();
}

void nano::scheduler::bucket::dump () const
{
for (auto const & item : queue)
{
std::cerr << item.time << ' ' << item.block->hash ().to_string () << '\n';
}
}
40 changes: 40 additions & 0 deletions nano/node/scheduler/bucket.hpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,40 @@
#pragma once

#include <cstddef>
#include <cstdint>
#include <memory>
#include <set>

namespace nano
{
class block;
}
namespace nano::scheduler
{
/** A class which holds an ordered set of blocks to be scheduled, ordered by their block arrival time
*/
class bucket final
{
class value_type
{
public:
uint64_t time;
std::shared_ptr<nano::block> block;
bool operator< (value_type const & other_a) const;
bool operator== (value_type const & other_a) const;
};
std::set<value_type> queue;
size_t const maximum;

public:
bucket (size_t maximum);
~bucket ();
bool available () const;
std::shared_ptr<nano::block> top () const;
void pop ();
void push (uint64_t time, std::shared_ptr<nano::block> block);
size_t size () const;
bool empty () const;
void dump () const;
};
} // namespace nano::scheduler
54 changes: 23 additions & 31 deletions nano/node/scheduler/buckets.cpp
Original file line number Diff line number Diff line change
@@ -1,19 +1,10 @@
#include <nano/lib/blocks.hpp>
#include <nano/lib/utility.hpp>
#include <nano/node/scheduler/bucket.hpp>
#include <nano/node/scheduler/buckets.hpp>

#include <string>

bool nano::scheduler::buckets::value_type::operator< (value_type const & other_a) const
{
return time < other_a.time || (time == other_a.time && block->hash () < other_a.block->hash ());
}

bool nano::scheduler::buckets::value_type::operator== (value_type const & other_a) const
{
return time == other_a.time && block->hash () == other_a.block->hash ();
}

/** Moves the bucket pointer to the next bucket */
void nano::scheduler::buckets::next ()
{
Expand All @@ -28,7 +19,7 @@ void nano::scheduler::buckets::next ()
void nano::scheduler::buckets::seek ()
{
next ();
for (std::size_t i = 0, n = schedule.size (); buckets_m[*current].empty () && i < n; ++i)
for (std::size_t i = 0, n = schedule.size (); !buckets_m[*current]->available () && i < n; ++i)
{
next ();
}
Expand Down Expand Up @@ -67,11 +58,19 @@ nano::scheduler::buckets::buckets (uint64_t maximum) :
build_region (uint128_t{ 1 } << 112, uint128_t{ 1 } << 116, 4);
build_region (uint128_t{ 1 } << 116, uint128_t{ 1 } << 120, 2);
minimums.push_back (uint128_t{ 1 } << 120);
buckets_m.resize (minimums.size ());
auto bucket_max = std::max<size_t> (1u, maximum / minimums.size ());
for (size_t i = 0u, n = minimums.size (); i < n; ++i)
{
buckets_m.push_back (std::make_unique<scheduler::bucket> (bucket_max));
}
populate_schedule ();
current = schedule.begin ();
}

nano::scheduler::buckets::~buckets ()
{
}

std::size_t nano::scheduler::buckets::index (nano::uint128_t const & balance) const
{
auto index = std::upper_bound (minimums.begin (), minimums.end (), balance) - minimums.begin () - 1;
Expand All @@ -86,11 +85,7 @@ void nano::scheduler::buckets::push (uint64_t time, std::shared_ptr<nano::block>
{
auto was_empty = empty ();
auto & bucket = buckets_m[index (priority.number ())];
bucket.emplace (value_type{ time, block });
if (bucket.size () > std::max (decltype (maximum){ 1 }, maximum / buckets_m.size ()))
{
bucket.erase (--bucket.end ());
}
bucket->push (time, block);
if (was_empty)
{
seek ();
Expand All @@ -101,28 +96,28 @@ void nano::scheduler::buckets::push (uint64_t time, std::shared_ptr<nano::block>
std::shared_ptr<nano::block> nano::scheduler::buckets::top () const
{
debug_assert (!empty ());
debug_assert (!buckets_m[*current].empty ());
auto result = buckets_m[*current].begin ()->block;
debug_assert (buckets_m[*current]->available ());
auto result = buckets_m[*current]->top ();
return result;
}

/** Pop the current block from the container and seek to the next block, if it exists */
void nano::scheduler::buckets::pop ()
{
debug_assert (!empty ());
debug_assert (!buckets_m[*current].empty ());
debug_assert (buckets_m[*current]->available ());
auto & bucket = buckets_m[*current];
bucket.erase (bucket.begin ());
bucket->pop ();
seek ();
}

/** Returns the total number of blocks in buckets */
std::size_t nano::scheduler::buckets::size () const
{
std::size_t result{ 0 };
for (auto const & queue : buckets_m)
for (auto const & bucket : buckets_m)
{
result += queue.size ();
result += bucket->size ();
}
return result;
}
Expand All @@ -136,24 +131,21 @@ std::size_t nano::scheduler::buckets::bucket_count () const
/** Returns number of items in bucket with index 'index' */
std::size_t nano::scheduler::buckets::bucket_size (std::size_t index) const
{
return buckets_m[index].size ();
return buckets_m[index]->size ();
}

/** Returns true if all buckets are empty */
bool nano::scheduler::buckets::empty () const
{
return std::all_of (buckets_m.begin (), buckets_m.end (), [] (priority const & bucket_a) { return bucket_a.empty (); });
return std::all_of (buckets_m.begin (), buckets_m.end (), [] (auto const & bucket) { return bucket->empty (); });
}

/** Print the state of the class in stderr */
void nano::scheduler::buckets::dump () const
{
for (auto const & i : buckets_m)
for (auto const & bucket : buckets_m)
{
for (auto const & j : i)
{
std::cerr << j.time << ' ' << j.block->hash ().to_string () << '\n';
}
bucket->dump ();
}
std::cerr << "current: " << std::to_string (*current) << '\n';
}
Expand All @@ -164,7 +156,7 @@ std::unique_ptr<nano::container_info_component> nano::scheduler::buckets::collec
for (auto i = 0; i < buckets_m.size (); ++i)
{
auto const & bucket = buckets_m[i];
composite->add_component (std::make_unique<container_info_leaf> (container_info{ std::to_string (i), bucket.size (), 0 }));
composite->add_component (std::make_unique<container_info_leaf> (container_info{ std::to_string (i), bucket->size (), 0 }));
}
return composite;
}
18 changes: 5 additions & 13 deletions nano/node/scheduler/buckets.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -3,15 +3,17 @@
#include <nano/lib/utility.hpp>

#include <cstddef>
#include <set>
#include <cstdint>
#include <deque>
#include <memory>

namespace nano
{
class block;
}
namespace nano::scheduler
{
class bucket;
/** A container for holding blocks and their arrival/creation time.
*
* The container consists of a number of buckets. Each bucket holds an ordered set of 'value_type' items.
Expand All @@ -24,19 +26,8 @@ namespace nano::scheduler
*/
class buckets final
{
class value_type
{
public:
uint64_t time;
std::shared_ptr<nano::block> block;
bool operator< (value_type const & other_a) const;
bool operator== (value_type const & other_a) const;
};

using priority = std::set<value_type>;

/** container for the buckets to be read in round robin fashion */
std::deque<priority> buckets_m;
std::deque<std::unique_ptr<bucket>> buckets_m;

/** thresholds that define the bands for each bucket, the minimum balance an account must have to enter a bucket,
* the container writes a block to the lowest indexed bucket that has balance larger than the bucket's minimum value */
Expand All @@ -57,6 +48,7 @@ class buckets final

public:
buckets (uint64_t maximum = 250000u);
~buckets ();
void push (uint64_t time, std::shared_ptr<nano::block> block, nano::amount const & priority);
std::shared_ptr<nano::block> top () const;
void pop ();
Expand Down

0 comments on commit 3480bfb

Please sign in to comment.