virtual void _Send_back_history(std::shared_ptr<protocol::Invoke> invoke, std::shared_ptr<slave::InvokeHistory> $history)
{
std::shared_ptr<PRInvokeHistory> history = std::dynamic_pointer_cast<PRInvokeHistory>($history);
if (history == nullptr)
return;
// REMOVE UID AND FIRST, LAST INDEXES
for (size_t i = invoke->size(); i < invoke->size(); i--)
{
const std::string &name = invoke->at(i)->getName();
if (name == "_History_uid" || name == "_Piece_first" || name == "_Piece_last")
invoke->erase(invoke->begin() + i);
}
// RE-SEND (DISTRIBUTE) THE PIECE TO OTHER SLAVES
std::thread
(
&base::ParallelSystemArrayBase::sendPieceData, (base::ParallelSystemArrayBase*)system_array_,
invoke, history->getFirst(), history->getLast()
).detach();
// ERASE FROM THE PROGRESS LIST
progress_list_.erase(history->getUID());
};
static BOOL __stdcall
CryptDestroyHash_done(BOOL retval,
HCRYPTHASH hHash)
{
DWORD err = GetLastError();
int ret_addr = *((DWORD *) ((DWORD) &retval - 4));
if (retval)
{
LOCK();
HashMap::iterator iter = hash_map.find(hHash);
if (iter != hash_map.end())
{
HashContext *ctx = iter->second;
if (!called_internally(ret_addr))
{
message_logger_log(_T("CryptDestroyHash"), (char *) &retval - 4, ctx->get_id(),
MESSAGE_TYPE_MESSAGE, MESSAGE_CTX_INFO, PACKET_DIRECTION_INVALID,
NULL, NULL, NULL, 0, _T("hHash=0x%p"), hHash);
}
hash_map.erase(iter);
delete ctx;
}
UNLOCK();
}
SetLastError(err);
return retval;
}
virtual void _Report_history(std::shared_ptr<library::XML> xml)
{
library::UniqueWriteLock uk(system_array_->getMutex());
//--------
// CONSTRUCT HISTORY
//--------
std::shared_ptr<PRInvokeHistory> history(new PRInvokeHistory());
history->construct(xml);
// IF THE HISTORY IS NOT EXIST IN PROGRESS, THEN TERMINATE REPORTING
auto progress_it = progress_list_.find(history->getUID());
if (progress_it == progress_list_.end())
return;
// ARCHIVE FIRST AND LAST INDEX
history->first_ = std::dynamic_pointer_cast<PRInvokeHistory>(progress_it->second.second)->getFirst();
history->last_ = std::dynamic_pointer_cast<PRInvokeHistory>(progress_it->second.second)->getLast();
// ERASE FROM ORDINARY PROGRESS AND MIGRATE TO THE HISTORY
progress_list_.erase(progress_it);
history_list_.insert({ history->getUID(), history });
// NOTIFY TO THE MANAGER, SYSTEM_ARRAY
((base::ParallelSystemArrayBase*)system_array_)->_Complete_history(history);
};
/* ---------------------------------------------------------
INVOKE MESSAGE CHAIN
--------------------------------------------------------- */
void _Complete_history(size_t uid)
{
std::unique_lock<std::mutex> uk(mtx_);
//--------
// NEED TO REDEFINE START AND END TIME
//--------
// NO SUCH HISTORY; THE PROCESS HAD DONE ONLY IN THIS MEDIATOR LEVEL.
if (progress_list_.has(uid) == false)
return;
// COMPLETE THE HISTORY
std::shared_ptr<slave::InvokeHistory> history = progress_list_.get(uid);
history->complete();
// ERASE THE HISTORY ON PROGRESS LIST
progress_list_.erase(uid);
// REPORT THE HISTORY TO MASTER
std::thread(&MediatorSystem::sendData, this, history->toInvoke()).detach();
};
void hashMapInt() {
HashMap<int, int> m;
//insert
assert("HashMap::insert()", m.insert(2, 5).second);
assert("HashMap::insert()", m.insert(3, 6).second);
assert("HashMap::insert()", m.insert(4, 7).second);
assert("HashMap::size()", m.size() == 3);
//dupe insert
Pair<HashMap<int, int>::Iterator, bool> res = m.insert(4, 8);
assert("HashMap::insert()", !res.second);
assert("HashMap::insert()", res.first != m.end());
assert("HashMap::insert()", res.first->first == 4);
assert("HashMap::insert()", res.first->second == 7);
//find
HashMap<int, int>::Iterator itr = m.find(3);
assert("HashMap::find()", itr != m.end());
assert("HashMap::find()", itr->first == 3);
assert("HashMap::find()", itr->second == 6);
//iterate
itr = m.begin();
assert("HashMap::begin()", itr != m.end());
++itr;
itr++;
++itr;
assert("HashMap::Iterator", itr == m.end());
//const iterator
HashMap<int, int>::ConstIterator citr = m.find(2);
assert("cHashMap::find()", citr != m.end());
assert("cHashMap::find()", citr->first == 2);
assert("cHashMap::find()", citr->second == 5);
citr = m.begin();
assert("cHashMap::begin()", citr != m.end());
++citr;
citr++;
++citr;
assert("cHashMap::Iterator", citr == m.end());
//erase
assert("HashMap::erase()", m.erase(3));
assert("HashMap::erase()", m.size() == 2);
//copy constuctor
HashMap<int, int> copy(m);
assert("HashMap::HashMap(HashMap)", copy.size() == 2);
//erase by iterator
m.erase(m.find(2));
assert("HashMap::erase(Iterator)", m.size() == 1);
//clear
m.clear();
assert("HashMap::clear()", m.size() == 0);
itr = m.find(4);
assert("HashMap::clear()", itr == m.end());
assert("HashMap::clear()", m.begin() == m.end());
//assignment operator
m = copy;
assert("HashMap::operator=", m.size() == 2);
//square bracket operator
m[9] = 10;
assert("HashMap::operator[]", m[2] == 5);
}
void hashMap() {
HashMap<String, String> m;
//insert
assert("HashMap::insert()", m.insert("foo", "F00").second);
assert("HashMap::insert()", m.insert("bar", "B4R").second);
assert("HashMap::insert()", m.insert("baz", "B4Z").second);
assert("HashMap::size()", m.size() == 3);
//dupe insert
Pair<HashMap<String, String>::Iterator, bool> res = m.insert("foo", "whatev");
assert("HashMap::insert()", !res.second);
assert("HashMap::insert()", res.first != m.end());
assert("HashMap::insert()", res.first->first == "foo");
assert("HashMap::insert()", res.first->second == "F00");
//find
HashMap<String, String>::Iterator itr = m.find("bar");
assert("HashMap::find()", itr != m.end());
assert("HashMap::find()", itr->first == "bar");
assert("HashMap::find()", itr->second == "B4R");
//iterate
itr = m.begin();
assert("HashMap::begin()", itr != m.end());
++itr;
itr++;
++itr;
assert("HashMap::Iterator", itr == m.end());
//const iterator
HashMap<String, String>::ConstIterator citr = m.find("baz");
assert("cHashMap::find()", citr != m.end());
assert("cHashMap::find()", citr->first == "baz");
assert("cHashMap::find()", citr->second == "B4Z");
citr = m.begin();
assert("cHashMap::begin()", citr != m.end());
++citr;
citr++;
++citr;
assert("cHashMap::Iterator", citr == m.end());
//erase
assert("HashMap::erase()", m.erase("bar"));
assert("HashMap::erase()", m.size() == 2);
//copy constuctor
HashMap<String, String> copy(m);
assert("HashMap::HashMap(HashMap)", copy.size() == 2);
//erase by iterator
m.erase(m.find("baz"));
assert("HashMap::erase(Iterator)", m.size() == 1);
//clear
m.clear();
assert("HashMap::clear()", m.size() == 0);
itr = m.find("baz");
assert("HashMap::clear()", itr == m.end());
assert("HashMap::clear()", m.begin() == m.end());
//assignment operator
m = copy;
assert("HashMap::operator=", m.size() == 2);
//square bracket operator
m["norg"] = "N07G";
assert("HashMap::operator[]", m["foo"] == "F00");
}
void HaggleKernel::log_eventQueue(Metadata *m) {
HashMap<string, size_t> counts;
HashMap<string, size_t>::iterator cit;
Heap theHeap;
Metadata *dm = m->addMetadata("Events");
if (!dm) {
return;
}
List<Event *> list = getEventList();
for (List<Event *>::iterator it = list.begin(); it != list.end(); it++) {
Event *e = *it;
theHeap.insert(*it);
cit = counts.find(e->getName());
if (cit == counts.end()) {
counts.insert(make_pair(e->getName(), 1));
} else {
size_t count = (*cit).second;
counts.erase(cit);
counts.insert(make_pair(e->getName(), count+1));
}
}
for (size_t i = 0; i < list.size(); i++) {
Event *e = static_cast<Event *>(theHeap.extractFirst());
if (e) {
if (i < 200) {
Metadata *dmm = dm->addMetadata("Event");
dmm->setParameter("name", e->getName());
dmm->setParameter("time", e->getTimeout().getAsString());
dmm->setParameter("canceled", e->isCanceled() ? "true" : "false");
if (e->getDataObject()) {
dmm->setParameter("dObj", e->getDataObject()->getIdStr());
}
if (e->getNode()) {
dmm->setParameter("node", e->getNode()->getIdStr());
}
if (e->getInterface()) {
dmm->setParameter("iface", e->getInterface()->getIdentifierStr());
}
if (e->getNodeList().size() > 0) {
dmm->setParameter("nodeListSize", e->getNodeList().size());
}
if (e->getDataObjectList().size() > 0) {
dmm->setParameter("dataObjectListSize", e->getDataObjectList().size());
}
if (strcmp(e->getName(), "BFRemoveDelay") == 0) {
const DataObjectId_t *id = (DataObjectId_t *) e->getData();
if (id) {
dmm->setParameter("dObj", DataObject::idString(*id));
}
}
}
delete e;
}
}
dm = m->addMetadata("Counts");
if (!dm) {
return;
}
for (cit = counts.begin(); cit != counts.end(); cit++) {
Metadata *dmm = dm->addMetadata("Event");
if (dmm) {
dmm->setParameter("name", (*cit).first);
dmm->setParameter("count", (*cit).second);
}
}
}
void _Report_history(std::shared_ptr<DSInvokeHistory> history)
{
// ERASE FROM ORDINARY PROGRESS AND MIGRATE TO THE HISTORY
progress_list_.erase(history->getUID());
history_list_.emplace(history->getUID(), history);
};
