7#include <boost/asio.hpp>
8#include <boost/format.hpp>
9#include <boost/iostreams/device/back_inserter.hpp>
10#include <boost/iostreams/stream.hpp>
11#include <boost/iostreams/stream_buffer.hpp>
12#include <boost/thread.hpp>
15#include <shared_mutex>
18#include <unordered_set>
31std::weak_ptr<T>
as_weak(std::shared_ptr<T> sp) {
32 return std::weak_ptr<T>(sp);
35template <
typename Int1,
typename Int2>
47std::vector<T>
asVector(
const Json::Value &json) {
49 v.reserve(json.size());
50 std::transform(json.begin(), json.end(), std::back_inserter(v),
51 [](
const Json::Value &item) { return T(item.asString()); });
57using stream = std::basic_streambuf<uint8_t>;
58using bufferstream = boost::iostreams::stream_buffer<boost::iostreams::basic_array_source<uint8_t>>;
59using vectorstream = boost::iostreams::stream_buffer<boost::iostreams::back_insert_device<std::vector<uint8_t>>>;
65 static_assert(std::is_standard_layout<T>::value,
"Cannot stream read non-standard layout types");
66 auto bytes(stm.sgetn(
reinterpret_cast<uint8_t *
>(&value),
sizeof(value)));
67 return bytes ==
sizeof(value);
72 static_assert(std::is_standard_layout<T>::value,
"Cannot stream write non-standard layout types");
73 auto bytes(stm.sputn(
reinterpret_cast<uint8_t
const *
>(&value),
sizeof(value)));
74 assert(
bytes ==
sizeof(value));
75 return bytes ==
sizeof(value);
91template <
typename K,
typename V>
96 std::pair<V, bool>
get(K
const &hash) {
100 auto kv = *(iter->second);
103 lru_.erase(iter->second);
124 lru_.push_front({hash, status});
133 auto iter =
status_.find(hash);
135 lru_.erase(iter->second);
136 lru_.push_front({hash, status});
142 bool update(K
const &hash, V status, V expected_status) {
145 auto iter =
status_.find(hash);
146 if (iter !=
status_.end() && iter->second == expected_status) {
147 lru_.erase(iter->second);
148 lru_.push_front({hash, status});
164 auto iter =
status_.find(hash);
166 lru_.erase(iter->second);
181 for (
int i = 0; i < sz; ++i) {
182 auto kv =
lru_.rbegin();
186 assert(!
lru_.empty());
192 std::unordered_map<K, typename std::list<std::pair<K, V>>::iterator>
status_;
193 std::list<std::pair<K, V>>
lru_;
196template <
typename... TS>
197std::string
fmt(
const std::string &pattern,
const TS &...args) {
198 return (boost::format(pattern) % ... % args).str();
222 std::unique_lock lock(
mtx_);
223 if (!
cache_.insert(key).second) {
239 std::shared_lock lck(
mtx_);
240 return cache_.contains(key);
244 std::unique_lock lck(
mtx_);
248 std::size_t
count(Key
const &key)
const {
249 std::shared_lock lck(
mtx_);
254 std::shared_lock lck(
mtx_);
259 std::unique_lock lck(
mtx_);
268 mutable std::shared_mutex
mtx_;
289 bool insert(Key
const &key, uint64_t block_number) {
294 std::unique_lock lock(this->
mtx_);
295 if (!this->
cache_.insert(key).second) {
304 this->
cache_.erase(exp.first);
312 if (this->
cache_.size() > this->kMaxSize) {
323 std::shared_lock lck(this->
mtx_);
335auto slice(std::vector<T>
const &v, std::size_t from = -1, std::size_t to = -1) {
337 return std::vector<T>(from == (std::size_t)-1 ? b : b + from, to == (std::size_t)-1 ? v.end() : b + to);
347template <
class Key,
class Value>
361 bool insert(Key
const &key, Value
const &value) {
363 std::shared_lock lock(
mtx_);
369 std::unique_lock lock(
mtx_);
372 if (!
cache_.emplace(key, value).second) {
383 std::size_t
count(Key
const &key)
const {
384 std::shared_lock lck(
mtx_);
389 std::shared_lock lck(
mtx_);
393 std::pair<Value, bool>
get(Key
const &key)
const {
394 std::shared_lock lck(
mtx_);
395 auto it =
cache_.find(key);
396 if (it ==
cache_.end())
return std::make_pair(Value(),
false);
397 return std::make_pair(it->second,
true);
401 std::unique_lock lck(
mtx_);
406 void update(Key
const &key, Value value) {
407 std::unique_lock lck(
mtx_);
425 std::unique_lock lck(
mtx_);
431 std::unique_lock lck(
mtx_);
432 std::pair<Value, bool> ret;
433 auto it =
cache_.find(key);
435 ret = std::make_pair(Value(),
false);
437 ret = std::make_pair(it->second,
true);
451 std::shared_lock lck(
mtx_);
455 bool update(Key
const &key, Value value, Value expected_value) {
456 std::unique_lock lck(
mtx_);
457 auto it =
cache_.find(key);
458 if (it !=
cache_.end() && it->second == expected_value) {
484 mutable std::shared_mutex
mtx_;
487template <
class Key,
class Value>
490 bool emplace(Key
const &key, Value
const &value) {
491 std::unique_lock lock(
mtx_);
492 return map_.emplace(key, value).second;
495 std::size_t
count(Key
const &key)
const {
496 std::shared_lock lck(
mtx_);
497 return map_.count(key);
501 std::shared_lock lck(
mtx_);
505 std::pair<Value, bool>
get(Key
const &key)
const {
506 std::shared_lock lck(
mtx_);
507 auto it =
map_.find(key);
508 if (it ==
map_.end())
return std::make_pair(Value(),
false);
509 return std::make_pair(it->second,
true);
513 std::vector<Value> values;
514 uint32_t counter = 0;
515 std::shared_lock lck(
mtx_);
516 values.reserve(
map_.size());
517 for (
auto const &t :
map_) {
518 values.emplace_back(t.second);
521 if (counter ==
count) {
529 void erase(std::function<
bool(Value)> condition) {
530 std::unique_lock lck(
mtx_);
531 for (
auto it =
map_.cbegin(), next_it = it; it !=
map_.cend(); it = next_it) {
533 if (condition(it->second)) {
540 std::unique_lock lck(
mtx_);
545 std::unique_lock lck(
mtx_);
546 return map_.erase(key);
550 std::unordered_map<Key, Value>
map_;
551 mutable std::shared_mutex
mtx_;
558 std::unique_lock lock(
mtx_);
559 return set_.insert(key).second;
562 std::size_t
count(Key
const &key)
const {
563 std::shared_lock lck(
mtx_);
564 return set_.count(key);
568 std::unique_lock lck(
mtx_);
573 std::unique_lock lck(
mtx_);
574 return set_.erase(key);
578 std::shared_lock lck(
mtx_);
584 mutable std::shared_mutex
mtx_;
ExpirationBlockNumberCache(uint32_t max_size, uint32_t delete_step, uint32_t blocks_to_keep)
Definition util.hpp:277
void clear()
Definition util.hpp:322
std::deque< std::pair< Key, uint64_t > > block_expiration_
Definition util.hpp:329
const uint32_t kBlocksToKeep
Definition util.hpp:330
bool insert(Key const &key, uint64_t block_number)
Inserts key into the cache map. In case provided key is already in cache, only shared lock is acquire...
Definition util.hpp:289
uint64_t last_block_number_
Definition util.hpp:331
const uint32_t kDeleteStep
Definition util.hpp:267
bool insert(Key const &key)
Inserts key into the cache map. In case provided key is already in cache, only shared lock is acquire...
Definition util.hpp:216
std::size_t count(Key const &key) const
Definition util.hpp:248
const uint32_t kMaxSize
Definition util.hpp:266
std::shared_mutex mtx_
Definition util.hpp:268
ExpirationCache(uint32_t max_size, uint32_t delete_step)
Definition util.hpp:206
void clear()
Definition util.hpp:258
bool contains(Key const &key) const
Definition util.hpp:238
void erase(Key const &key)
Definition util.hpp:243
std::unordered_set< Key > cache_
Definition util.hpp:265
std::size_t size() const
Definition util.hpp:253
std::deque< Key > expiration_
Definition util.hpp:271
virtual void eraseOldest()
Definition util.hpp:473
bool insert(Key const &key, Value const &value)
Inserts <key,value> pair into the cache map. In case provided key is already in cache,...
Definition util.hpp:361
std::size_t size() const
Definition util.hpp:388
std::unordered_map< Key, Value > getRawMap()
Definition util.hpp:450
std::size_t count(Key const &key) const
Definition util.hpp:383
std::pair< Value, bool > get(Key const &key) const
Definition util.hpp:393
std::deque< Key > expiration_
Definition util.hpp:481
std::unordered_map< Key, Value > cache_
Definition util.hpp:480
ExpirationCacheMap(uint32_t max_size, uint32_t delete_step)
Definition util.hpp:350
void erase(const Key &key)
Definition util.hpp:424
const uint32_t kDeleteStep
Definition util.hpp:483
void update(Key const &key, Value value)
Definition util.hpp:406
std::shared_mutex mtx_
Definition util.hpp:484
std::pair< Value, bool > updateWithGet(Key const &key, Value value)
Definition util.hpp:430
const uint32_t kMaxSize
Definition util.hpp:482
bool update(Key const &key, Value value, Value expected_value)
Definition util.hpp:455
void clear()
Definition util.hpp:400
std::shared_mutex mtx_
Definition util.hpp:551
std::unordered_map< Key, Value > map_
Definition util.hpp:550
bool erase(const Key &key)
Definition util.hpp:544
bool emplace(Key const &key, Value const &value)
Definition util.hpp:490
std::size_t count(Key const &key) const
Definition util.hpp:495
std::vector< Value > getValues(uint32_t count=0) const
Definition util.hpp:512
std::size_t size() const
Definition util.hpp:500
std::pair< Value, bool > get(Key const &key) const
Definition util.hpp:505
void clear()
Definition util.hpp:539
void erase(std::function< bool(Value)> condition)
Definition util.hpp:529
void clear()
Definition util.hpp:567
bool emplace(Key const &key)
Definition util.hpp:557
bool erase(const Key &key)
Definition util.hpp:572
std::unordered_set< Key > set_
Definition util.hpp:583
std::size_t size() const
Definition util.hpp:577
std::size_t count(Key const &key) const
Definition util.hpp:562
std::shared_mutex mtx_
Definition util.hpp:584
Class for writing to an RLP bytestream.
Definition RLP.h:484
bytes && invalidate()
Invalidate the object and steal the output byte stream.
Definition RLP.h:620
void clearOldData()
Definition util.hpp:179
size_t capacity_
Definition util.hpp:190
bool update(K const &hash, V status, V expected_status)
Definition util.hpp:142
StatusTable(size_t capacity=10000)
Definition util.hpp:95
bool erase(K const &hash)
Definition util.hpp:161
std::list< std::pair< K, V > > lru_
Definition util.hpp:193
void update(K const &hash, V status)
Definition util.hpp:131
std::shared_mutex shared_mutex_
Definition util.hpp:191
bool insert(K const &hash, V status)
Definition util.hpp:115
std::unordered_map< K, typename std::list< std::pair< K, V > >::iterator > status_
Definition util.hpp:192
void clear()
Definition util.hpp:156
std::unordered_map< K, V > UnsafeStatusTable
Definition util.hpp:94
std::pair< V, bool > get(K const &hash)
Definition util.hpp:96
unsigned long size() const
Definition util.hpp:111
std::list< std::pair< K, V > > Element
Definition util.hpp:189
UnsafeStatusTable getThreadUnsafeCopy() const
Definition util.hpp:173
std::basic_streambuf< uint8_t > stream
Definition util.hpp:57
void thisThreadSleepForMicroSeconds(unsigned microsec)
Definition util.cpp:17
bool read(stream &stm, T &value)
Definition util.hpp:64
void thisThreadSleepForMilliSeconds(unsigned millisec)
Definition util.cpp:13
std::weak_ptr< T > as_weak(std::shared_ptr< T > sp)
Definition util.hpp:31
boost::iostreams::stream_buffer< boost::iostreams::back_insert_device< std::vector< uint8_t > > > vectorstream
Definition util.hpp:59
std::vector< byte > bytes
Definition types.hpp:53
std::string getFormattedVersion(std::initializer_list< uint32_t > list)
Definition util.cpp:26
void thisThreadSleepForSeconds(unsigned sec)
Definition util.cpp:11
std::string fmt(const std::string &pattern, const TS &...args)
Definition util.hpp:197
bool write(stream &stm, T const &value)
Definition util.hpp:71
std::vector< T > asVector(const Json::Value &json)
Definition util.hpp:47
std::vector< uint64_t > asUInt64Vector(const Json::Value &json)
Definition util.cpp:34
std::string jsonToUnstyledString(const Json::Value &value)
Definition util.cpp:5
boost::iostreams::stream_buffer< boost::iostreams::basic_array_source< uint8_t > > bufferstream
Definition util.hpp:58
auto int_pow(Int1 x, Int2 y)
Definition util.hpp:36
unsigned long getCurrentTimeMilliSeconds()
Definition util.cpp:21
auto slice(std::vector< T > const &v, std::size_t from=-1, std::size_t to=-1)
Definition util.hpp:335
auto getRlpBytes(T const &t)
Definition util.hpp:341