MME2 changes - Propped commits from openmme/paging branch. Added scripts
for code gen
Change-Id: Ie55032217232214ac8544ca76ea34335205329e4
diff --git a/src/stateMachineFwk/controlBlock.cpp b/src/stateMachineFwk/controlBlock.cpp
new file mode 100644
index 0000000..1c41139
--- /dev/null
+++ b/src/stateMachineFwk/controlBlock.cpp
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2019, Infosys Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <iostream>
+#include <string>
+#include "controlBlock.h"
+#include "event.h"
+#include "log.h"
+#include "tempDataBlock.h"
+#include <stateMachineEngine.h>
+
+using namespace std;
+
+namespace SM
+{
+ uint32_t ControlBlock::controlBlockArrayIdx = 0;
+
+ ControlBlock::ControlBlock():mutex_m(), cbIndex_m(++controlBlockArrayIdx),
+ cbState_m(FREE), data_p(NULL), pdb_mp(NULL),
+ tdb_mp(NULL), inProcQueue_m(false)
+ {
+ for (int i = 0; i < MAX_FAST_BLOCK_IDX; i++)
+ fadb_mpa[i] = NULL;
+
+ std::queue<Event> emptyQ;
+ std::swap( eventQ, emptyQ );
+
+ std::deque<debugEventInfo> emptyDQ;
+ std::swap(debugEventInfoQ, emptyDQ);
+ }
+
+ void ControlBlock::reset()
+ {
+ std::lock_guard<std::mutex> lock(mutex_m);
+
+ cbState_m = FREE;
+
+ data_p = NULL;
+ pdb_mp = NULL;
+
+ for (int i = 0; i < MAX_FAST_BLOCK_IDX; i++)
+ fadb_mpa[i] = NULL;
+
+ tdb_mp = NULL;
+
+ inProcQueue_m = false;
+
+ std::queue<Event> emptyQ;
+ std::swap( eventQ, emptyQ );
+
+ std::deque<debugEventInfo> emptyDQ;
+ std::swap(debugEventInfoQ, emptyDQ);
+ }
+
+ ControlBlock::~ControlBlock()
+ {
+ }
+
+ bool ControlBlock::getCurrentEvent(Event &evt)
+ {
+ std::lock_guard<std::mutex> lock(mutex_m);
+
+ if(eventQ.empty())
+ return false;
+
+ evt = eventQ.front();
+ eventQ.pop();
+
+ setMsgData(evt.getEventData());
+
+ return true;
+ }
+
+ State* ControlBlock::getCurrentState()
+ {
+ return tdb_mp->getCurrentState();
+ }
+
+ void ControlBlock::display()
+ {
+ log_msg(LOG_DEBUG,"Displaying control block");
+
+ pdb_mp->display();
+
+ tdb_mp->display();
+
+ }
+
+ void ControlBlock::addEventToProcQ(Event &event)
+ {
+ std::lock_guard<std::mutex> lock(mutex_m);
+
+ if (cbState_m == ALLOCATED)
+ {
+ eventQ.push(event);
+ if (inProcQueue_m == false)
+ {
+ inProcQueue_m = true;
+ if (!SM::StateMachineEngine::Instance()->addCBToProcQ(this))
+ {
+ inProcQueue_m = false;
+ }
+ }
+ }
+ }
+
+ void ControlBlock::setNextState(State* state)
+ {
+ if (tdb_mp != NULL)
+ tdb_mp->setNextState(state);
+ }
+
+ PermDataBlock* ControlBlock::getFastAccessBlock(unsigned short idx) const
+ {
+ PermDataBlock* permBlock_p = NULL;
+
+ if (idx < ControlBlock::MAX_FAST_BLOCK_IDX)
+ permBlock_p = fadb_mpa[idx];
+
+ return permBlock_p;
+ }
+
+ void ControlBlock::setFastAccessBlock(
+ PermDataBlock* pdb_p, unsigned short idx)
+ {
+ if (idx < ControlBlock::MAX_FAST_BLOCK_IDX)
+ fadb_mpa[idx] = pdb_p;
+ }
+
+ PermDataBlock* ControlBlock::getPermDataBlock() const
+ {
+ return pdb_mp;
+ }
+
+ void ControlBlock::setPermDataBlock(PermDataBlock* pdb_p)
+ {
+ pdb_mp = pdb_p;
+ }
+
+ TempDataBlock* ControlBlock::getTempDataBlock() const
+ {
+ return tdb_mp;
+ }
+
+ void ControlBlock::setTempDataBlock(TempDataBlock* tdb_p)
+ {
+ if (tdb_p == NULL)
+ return;
+
+ tdb_mp = tdb_p;
+ }
+
+ void ControlBlock::setCurrentTempDataBlock(TempDataBlock* tdb_p)
+ {
+ if (tdb_p == NULL)
+ return;
+
+ if (tdb_mp != NULL)
+ {
+ tdb_p->setNextTempDataBlock(tdb_mp);
+ }
+
+ tdb_mp = tdb_p;
+ }
+
+ void ControlBlock::addDebugInfo(debugEventInfo& eventInfo)
+ {
+ if(debugEventInfoQ.size()>=10)
+ {
+ debugEventInfoQ.pop_front();
+ }
+ debugEventInfoQ.push_back(eventInfo);
+ }
+
+ uint32_t ControlBlock::getCBIndex()
+ {
+ return cbIndex_m;
+ }
+
+ void ControlBlock::setControlBlockState(ControlBlockState state)
+ {
+ std::lock_guard<std::mutex> lock(mutex_m);
+
+ log_msg(LOG_INFO, "CB state transition from %d to %d\n", cbState_m, state);
+
+ cbState_m = state;
+ }
+
+ ControlBlockState ControlBlock::getControlBlockState()
+ {
+ std::lock_guard<std::mutex> lock(mutex_m);
+
+ return cbState_m;
+ }
+
+ void ControlBlock::setProcQueueFlag(bool flag)
+ {
+ std::lock_guard<std::mutex> lock(mutex_m);
+ inProcQueue_m = flag;
+ }
+
+ bool ControlBlock::isInProcQueue()
+ {
+ std::lock_guard<std::mutex> lock(mutex_m);
+ return inProcQueue_m;
+ }
+}