LBRYCommunity/lbrycrd
1
0
Fork 0
Code Issues 29 Pull requests 1 Projects Releases 32 Packages Wiki Activity

Convert ForEachNode* functions to take a templated function argument rather than a std::function to eliminate std::function overhead

Browse source
This commit is contained in:
Jeremy Rubin 2016-06-19 21:42:15 -04:00 committed by Cory Fields
parent d1a2295f0d
commit e700cd0bc8
2 changed files with 82 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

73
src/net.cpp
View file

@ -2697,79 +2697,6 @@ bool CConnman::ForNode(NodeId id, std::function<bool(CNode* pnode)> func)
return found != nullptr && func(found);
}
bool CConnman::ForEachNodeContinueIf(std::function<bool(CNode* pnode)> func)
{
LOCK(cs_vNodes);
for (auto&& node : vNodes)
if(!func(node))
return false;
return true;
}
bool CConnman::ForEachNodeContinueIf(std::function<bool(const CNode* pnode)> func) const
{
LOCK(cs_vNodes);
for (const auto& node : vNodes)
if(!func(node))
return false;
return true;
}
bool CConnman::ForEachNodeContinueIfThen(std::function<bool(CNode* pnode)> pre, std::function<void()> post)
{
bool ret = true;
LOCK(cs_vNodes);
for (auto&& node : vNodes)
if(!pre(node)) {
ret = false;
break;
}
post();
return ret;
}
bool CConnman::ForEachNodeContinueIfThen(std::function<bool(const CNode* pnode)> pre, std::function<void()> post) const
{
bool ret = true;
LOCK(cs_vNodes);
for (const auto& node : vNodes)
if(!pre(node)) {
ret = false;
break;
}
post();
return ret;
}
void CConnman::ForEachNode(std::function<void(CNode* pnode)> func)
{
LOCK(cs_vNodes);
for (auto&& node : vNodes)
func(node);
}
void CConnman::ForEachNode(std::function<void(const CNode* pnode)> func) const
{
LOCK(cs_vNodes);
for (const auto& node : vNodes)
func(node);
}
void CConnman::ForEachNodeThen(std::function<void(CNode* pnode)> pre, std::function<void()> post)
{
LOCK(cs_vNodes);
for (auto&& node : vNodes)
pre(node);
post();
}
void CConnman::ForEachNodeThen(std::function<void(const CNode* pnode)> pre, std::function<void()> post) const
{
LOCK(cs_vNodes);
for (const auto& node : vNodes)
pre(node);
post();
}
int64_t PoissonNextSend(int64_t nNow, int average_interval_seconds) {
return nNow + (int64_t)(log1p(GetRand(1ULL << 48) * -0.0000000000000035527136788 /* -1/2^48 */) * average_interval_seconds * -1000000.0 + 0.5);
}

90
src/net.h
View file

@ -129,14 +129,88 @@ public:
bool CheckIncomingNonce(uint64_t nonce);
bool ForNode(NodeId id, std::function<bool(CNode* pnode)> func);
bool ForEachNodeContinueIf(std::function<bool(CNode* pnode)> func);
bool ForEachNodeContinueIf(std::function<bool(const CNode* pnode)> func) const;
bool ForEachNodeContinueIfThen(std::function<bool(CNode* pnode)> pre, std::function<void()> post);
bool ForEachNodeContinueIfThen(std::function<bool(const CNode* pnode)> pre, std::function<void()> post) const;
void ForEachNode(std::function<void(CNode* pnode)> func);
void ForEachNode(std::function<void(const CNode* pnode)> func) const;
void ForEachNodeThen(std::function<void(CNode* pnode)> pre, std::function<void()> post);
void ForEachNodeThen(std::function<void(const CNode* pnode)> pre, std::function<void()> post) const;
template<typename Callable>
bool ForEachNodeContinueIf(Callable&& func)
{
LOCK(cs_vNodes);
for (auto&& node : vNodes)
if(!func(node))
return false;
return true;
};
template<typename Callable>
bool ForEachNodeContinueIf(Callable&& func) const
{
LOCK(cs_vNodes);
for (const auto& node : vNodes)
if(!func(node))
return false;
return true;
};
template<typename Callable, typename CallableAfter>
bool ForEachNodeContinueIfThen(Callable&& pre, CallableAfter&& post)
{
bool ret = true;
LOCK(cs_vNodes);
for (auto&& node : vNodes)
if(!pre(node)) {
ret = false;
break;
}
post();
return ret;
};
template<typename Callable, typename CallableAfter>
bool ForEachNodeContinueIfThen(Callable&& pre, CallableAfter&& post) const
{
bool ret = true;
LOCK(cs_vNodes);
for (const auto& node : vNodes)
if(!pre(node)) {
ret = false;
break;
}
post();
return ret;
};
template<typename Callable>
void ForEachNode(Callable&& func)
{
LOCK(cs_vNodes);
for (auto&& node : vNodes)
func(node);
};
template<typename Callable>
void ForEachNode(Callable&& func) const
{
LOCK(cs_vNodes);
for (const auto& node : vNodes)
func(node);
};
template<typename Callable, typename CallableAfter>
void ForEachNodeThen(Callable&& pre, CallableAfter&& post)
{
LOCK(cs_vNodes);
for (auto&& node : vNodes)
pre(node);
post();
};
template<typename Callable, typename CallableAfter>
void ForEachNodeThen(Callable&& pre, CallableAfter&& post) const
{
LOCK(cs_vNodes);
for (const auto& node : vNodes)
pre(node);
post();
};
void RelayTransaction(const CTransaction& tx);