int main(int argc, char **argv)
{
EventList eventlist;
ProcessList processes;
long ev_EndSimulation = 0;
Traverser traverser(&eventlist);
ColdTestCell cell1(&eventlist,&traverser);
ColdTestCell cell2(&eventlist, &traverser);
ColdTestCell cell3(&eventlist, &traverser);
Source supply(&eventlist, &traverser);
Sink derig(&eventlist);
processes.push_back(&traverser);
processes.push_back(&cell1);
processes.push_back(&cell2);
processes.push_back(&cell3);
processes.push_back(&supply);
processes.push_back(&derig);
// Connect up production layout
traverser.cell1(&cell1);
traverser.cell2(&cell2);
traverser.cell3(&cell3);
traverser.infeed(&supply);
traverser.outfeed(&derig);
// Initialise the processes
eventlist.push(new Event(100000,
nullptr,
ev_EndSimulation)); // End Simulation Event
bool change;
do {
change = false;
for (ProcessList::iterator i = processes.begin();
i != processes.end(); i++)
change |= (*i)->run(); // Run each process until no change
} while (change);
// Run the event management loop.
while (Event *event = eventlist.top()) {
eventlist.pop(); // Remove the top element from the list
SimulationTime += event->getTime(); // Advance simulation time
if (event->getEventType() == ev_EndSimulation)
break;
event->getProcess()->HandleEvent(event);
delete event; // no longer needed
}
}
// *******************************************************************************************************************
void cProcessManager::VGetProcesses(const cHashedString & Type, ProcessList & pProcessList)
{
for (auto curProcess = m_pProcessList.begin(); curProcess != m_pProcessList.end(); curProcess++)
{
shared_ptr<cProcess> p(*curProcess);
if(p->VGetType() == Type)
{
pProcessList.push_back(p);
}
}
}
ProcessList QtProcessFinder::search() {
ProcessList list;
HANDLE hProcessSnap;
HANDLE hProcess;
PROCESSENTRY32 pe32;
DWORD dwPriorityClass;
// Take a snapshot of all processes in the system.
hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hProcessSnap == INVALID_HANDLE_VALUE) {
qFatal("CreateToolhelp32Snapshot (of processes)");
return list;
}
// Set the size of the structure before using it.
pe32.dwSize = sizeof(PROCESSENTRY32);
// Retrieve information about the first process,
// and exit if unsuccessful
if (!Process32First(hProcessSnap, &pe32)) {
qFatal("Process32First"); // show cause of failure
CloseHandle(hProcessSnap); // clean the snapshot object
return list;
}
// Now walk the snapshot of processes, and
// display information about each process in turn
do {
// Skip the system idle process
if (pe32.th32ProcessID == 0) continue;
// Retrieve the priority class.
dwPriorityClass = 0;
hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);
if (hProcess == NULL)
qDebug("OpenProcess");
else {
dwPriorityClass = GetPriorityClass(hProcess);
if (!dwPriorityClass) qDebug("GetPriorityClass");
CloseHandle(hProcess);
}
// List the modules and threads associated with this process
if (processUsesQt(pe32.th32ProcessID)) {
list.push_back(Process(pe32.th32ProcessID, QString::fromStdWString(pe32.szExeFile)));
}
} while (Process32Next(hProcessSnap, &pe32));
CloseHandle(hProcessSnap);
return list;
}
// *****************************************************************************
void cProcessManager::VGetProcesses(const cString & strType, ProcessList & pProcessList)
{
ProcessList::iterator curProcess;
unsigned long hash = cHashedString::CalculateHash(strType);
for (curProcess = m_pProcessList.begin(); curProcess != m_pProcessList.end(); curProcess++)
{
shared_ptr<cProcess> p(*curProcess);
if(p->m_strType.GetHash() == hash)
{
pProcessList.push_back(p);
}
}
}
ProcessList Process::GetList()
{
Handle hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (!hSnapshot.IsValid())
{
THROW_LAST_ERROR_EXCEPTION();
}
PROCESSENTRY32 processEntry = {0};
processEntry.dwSize = sizeof(processEntry);
BOOL success = ::Process32First(hSnapshot, &processEntry);
if (!success)
{
THROW_LAST_ERROR_EXCEPTION();
}
ProcessList list;
while (success)
{
#ifdef _DEBUG
//if (_wcsicmp(processEntry.szExeFile, L"winword.exe") == 0 ||
// _wcsicmp(processEntry.szExeFile, L"iexplore.exe") == 0 ||
// wcscmp(processEntry.szExeFile, L"firefox.exe") == 0 ||
// wcsncmp(processEntry.szExeFile, L"FlashPlayerPlugin", 17) == 0 ||
// wcscmp(processEntry.szExeFile, L"AccessEnum.exe") == 0 ||
// wcscmp(processEntry.szExeFile, L"TSVNCache.exe") == 0 ||
// wcscmp(processEntry.szExeFile, L"plugin-container.exe") == 0)
#endif
list.push_back(Process(
processEntry.th32ProcessID,
processEntry.th32ParentProcessID,
processEntry.szExeFile));
success = ::Process32Next(hSnapshot, &processEntry);
}
return list;
}
void
Group::detachedProcessesCheckerMain(GroupPtr self) {
TRACE_POINT();
Pool *pool = getPool();
Pool::DebugSupportPtr debug = pool->debugSupport;
if (debug != NULL && debug->detachedProcessesChecker) {
debug->debugger->send("About to start detached processes checker");
debug->messages->recv("Proceed with starting detached processes checker");
}
boost::unique_lock<boost::mutex> lock(pool->syncher);
while (true) {
assert(detachedProcessesCheckerActive);
if (getLifeStatus() == SHUT_DOWN || this_thread::interruption_requested()) {
UPDATE_TRACE_POINT();
P_DEBUG("Stopping detached processes checker");
detachedProcessesCheckerActive = false;
break;
}
UPDATE_TRACE_POINT();
if (!detachedProcesses.empty()) {
P_TRACE(2, "Checking whether any of the " << detachedProcesses.size() <<
" detached processes have exited...");
ProcessList::iterator it, end = detachedProcesses.end();
ProcessList processesToRemove;
for (it = detachedProcesses.begin(); it != end; it++) {
const ProcessPtr process = *it;
switch (process->getLifeStatus()) {
case Process::ALIVE:
if (process->canTriggerShutdown()) {
P_DEBUG("Detached process " << process->inspect() <<
" has 0 active sessions now. Triggering shutdown.");
process->triggerShutdown();
assert(process->getLifeStatus() == Process::SHUTDOWN_TRIGGERED);
}
break;
case Process::SHUTDOWN_TRIGGERED:
if (process->canCleanup()) {
P_DEBUG("Detached process " << process->inspect() << " has shut down. Cleaning up associated resources.");
process->cleanup();
assert(process->getLifeStatus() == Process::DEAD);
processesToRemove.push_back(process);
} else if (process->shutdownTimeoutExpired()) {
P_WARN("Detached process " << process->inspect() <<
" didn't shut down within " PROCESS_SHUTDOWN_TIMEOUT_DISPLAY
". Forcefully killing it with SIGKILL.");
kill(process->getPid(), SIGKILL);
}
break;
default:
P_BUG("Unknown 'lifeStatus' state " << (int) process->getLifeStatus());
}
}
UPDATE_TRACE_POINT();
end = processesToRemove.end();
for (it = processesToRemove.begin(); it != end; it++) {
removeProcessFromList(*it, detachedProcesses);
}
}
UPDATE_TRACE_POINT();
if (detachedProcesses.empty()) {
UPDATE_TRACE_POINT();
P_DEBUG("Stopping detached processes checker");
detachedProcessesCheckerActive = false;
boost::container::vector<Callback> actions;
if (shutdownCanFinish()) {
UPDATE_TRACE_POINT();
finishShutdown(actions);
}
verifyInvariants();
verifyExpensiveInvariants();
lock.unlock();
UPDATE_TRACE_POINT();
runAllActions(actions);
break;
} else {
UPDATE_TRACE_POINT();
verifyInvariants();
verifyExpensiveInvariants();
}
// Not all processes can be shut down yet. Sleep for a while unless
// someone wakes us up.
UPDATE_TRACE_POINT();
detachedProcessesCheckerCond.timed_wait(lock,
posix_time::milliseconds(100));
}
}
