void RChannelFifoWriter::InterruptSupplier()
{
bool waitForLatch;
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_supplierState == SS_Running);
/* remove any spare FIFO slots since we aren't going to send
anything more to the supplier */
m_availableUnits = 0;
m_supplierState = SS_Interrupted;
waitForLatch = m_sendLatch.Interrupt();
}
if (waitForLatch)
{
/* make sure all sends which were proceeding outside a lock
have completed */
m_sendLatch.Wait();
}
}
DWORD WINAPI UpdateThreadProc(LPVOID pData)
{
Player *player = (Player *)pData;
player_data_s &pd = *(player_data_s *)&player->data;
DWORD prevTime = timeGetTime();
while (WaitForSingleObject(pd.hQuitEvent, 17) != WAIT_OBJECT_0)
{
AutoCriticalSection acs(pd.critSect);
DWORD time = timeGetTime();
float dt = (time - prevTime)*(1/1000.f);
for (int g=0; g<pd.sgCount; g++)
{
Slot *slots = pd.soundGroups[g].slots;
for (int i=0, n=pd.soundGroups[g].active; i<n; i++) slots[i].update(player, dt, false);
}
/*if (dsListener) */pd.dsListener->CommitDeferredSettings();
prevTime = time;
}
return 0;
}
void DryadSubGraphVertex::VertexCompleted(DrError status,
DryadMetaData* errorData)
{
bool finished = false;
{
AutoCriticalSection acs(&m_baseCS);
LogAssert(GetErrorCode() != DryadError_VertexCompleted);
if (status == DryadError_VertexCompleted)
{
status = DrError_OK;
}
if (NoError())
{
ReportError(status, errorData);
}
LogAssert(m_outstandingVertices > 0);
--m_outstandingVertices;
if (m_outstandingVertices == 0)
{
finished = true;
}
}
if (finished)
{
/* the real status will be returned in AsyncPostCompletion
after we have exited all handlers. */
m_handler->ProgramCompleted();
}
}
void RChannelReaderImpl::AddUnitList(ChannelUnitList* unitList)
{
ChannelProcessRequestList requestList;
ChannelUnitList returnUnitList;
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_state == RS_Running ||
m_state == RS_InterruptingSupplier);
DrBListEntry* listEntry = unitList->RemoveHead();
while (listEntry != NULL)
{
RChannelUnit* unit = unitList->CastOut(listEntry);
AddUnitToQueue("RChannelReaderImpl::AddUnitList",
unit, &requestList, &returnUnitList);
listEntry = unitList->RemoveHead();
}
FOO(&requestList);
m_sendLatch.AcceptList(&requestList);
m_unitLatch.AcceptList(&returnUnitList);
}
DispatchRequests("RChannelReaderImpl::AddUnitList",
&requestList, &returnUnitList);
}
void DeinitModuleDescriptions(
const wchar_t * module,
bool bLoc)
{
module = KLSTD::FixNullString(module);
try
{
AutoCriticalSection acs(KLERR::g_pModulesCS);
modules_t* pModules = GetModulesCS(bLoc);
KLSTD_ASSERT(pModules);
if(!pModules)
return;
;
modules_t::iterator it=pModules->find(module);
if(it != pModules->end())
{
delete it->second;
pModules->erase(it);
};
}
catch(std::exception& err)
{
KLERR_TRACE_UNEXPECTED();
};
};
void RChannelFifoWriter::Start()
{
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_writerState == WS_Stopped);
LogAssert(m_availableUnits == 0);
LogAssert(m_blockedList.IsEmpty());
LogAssert(m_reader != NULL);
LogAssert(m_nextDataSequenceNumber == 0);
LogAssert(m_nextDeliverySequenceNumber == 0);
LogAssert(m_outstandingUnits == 0);
LogAssert(m_terminationUnit == NULL);
m_sendLatch.Start();
m_returnLatch.Start();
m_writerTerminationItem = NULL;
m_readerTerminationItem = NULL;
m_numberOfSubItemsWritten = 0;
m_dataSizeWritten = 0;
LogAssert(m_supplierEpoch == m_writerEpoch);
BOOL bRet = ::ResetEvent(m_writerDrainEvent);
LogAssert(bRet != 0);
if (m_supplierState == SS_Running)
{
m_availableUnits = m_fifoLength;
}
m_writerState = WS_Running;
}
}
RChannelItemType RChannelFifoWriterBase::
WriteItemArraySync(RChannelItemArrayRef& itemArray,
bool flush,
RChannelItemArrayRef* pFailureArray)
{
SyncHandler syncHandler;
if (pFailureArray != NULL)
{
*pFailureArray = NULL;
}
EnqueueItemArray(itemArray, &syncHandler, &syncHandler);
if (syncHandler.UsingEvent())
{
syncHandler.Wait();
{
AutoCriticalSection acs(&m_baseDR);
m_eventCache.ReturnEvent(syncHandler.GetEvent());
}
}
return syncHandler.GetStatusCode();
}
KLSTD_NOTHROW size_t CError::LocGetParCount() throw()
{
KLSTD::AutoCriticalSection acs(g_pErrorCS);
return m_pLocInfo
? m_pLocInfo->m_vecArgs.size()
: 0u;
};
void RChannelFifoNBWriter::AcceptReturningUnit(RChannelFifoUnit* unit)
{
bool wakeUpSupplierDrain = false;
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_outstandingUnits > 0);
--m_outstandingUnits;
if (m_supplierState == SS_Draining)
{
/* the supplier has requested a drain */
if (m_outstandingUnits == 0)
{
m_supplierState = SS_Stopped;
++m_supplierEpoch;
wakeUpSupplierDrain = true;
}
}
}
if (wakeUpSupplierDrain)
{
BOOL bRet = ::SetEvent(m_supplierDrainEvent);
LogAssert(bRet != 0);
}
delete unit;
}
void RChannelFifoWriterBase::ReturnHandlers(ChannelFifoUnitList* returnList)
{
while (returnList->IsEmpty() == false)
{
RChannelFifoUnit* returnUnit =
returnList->CastOut(returnList->RemoveHead());
while (returnUnit != NULL)
{
RChannelItemArrayWriterHandler* handler;
RChannelItemType statusCode;
returnUnit->Disgorge(&handler, &statusCode);
if (handler != NULL)
{
handler->ProcessWriteArrayCompleted(statusCode, NULL);
}
delete returnUnit;
returnUnit =
returnList->CastOut(returnList->RemoveHead());
}
{
AutoCriticalSection acs(&m_baseDR);
m_returnLatch.TransferList(returnList);
}
}
}
//
// Notify GM of completed vertex
//
void DVertexPnController::Terminate(DrError vertexState,
UInt32 exitCode)
{
LogAssert(vertexState != DryadError_VertexRunning);
if (vertexState == DrError_OK)
{
LogAssert(exitCode == DrExitCode_StillActive);
}
//
// take Critical section to update vertex state
//
{
AutoCriticalSection acs(&m_baseCS);
m_currentStatus->SetVertexState(vertexState);
}
//
// Log vertex termination
//
DrLogI( "Terminating vertex. Vertex %u.%u exitCode %s vertexState %s",
m_currentStatus->GetProcessStatus()->GetVertexId(),
m_currentStatus->GetProcessStatus()->GetVertexInstanceVersion(),
DREXITCODESTRING(exitCode), DRERRORSTRING(vertexState));
//
// Send status to GM
//
SendStatus(exitCode, true);
}
void RChannelFifoNBWriter::
StartSupplier(RChannelBufferPrefetchInfo* prefetchCookie)
{
ChannelUnitList unblockedList;
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_supplierState == SS_Stopped);
LogAssert(m_writerState != WS_Closed);
LogAssert(m_outstandingUnits == 0);
BOOL bRet = ::ResetEvent(m_supplierDrainEvent);
LogAssert(bRet != 0);
m_supplierState = SS_Running;
while (m_blockedList.IsEmpty() == false)
{
++m_outstandingUnits;
RChannelFifoUnit* blockedUnit =
m_blockedList.CastOut(m_blockedList.GetHead());
unblockedList.TransitionToTail(unblockedList.
CastIn(blockedUnit));
}
m_sendLatch.AcceptList(&unblockedList);
}
SendUnits(&unblockedList);
}
HRESULT SceneGraph::RegisterNotificationListener(__in ISceneChangesNotificationListener *pListener, SceneObjectContentType mask)
{
if (pListener == NULL)
return E_INVALIDARG;
AutoCriticalSection acs(m_Validation);
HRESULT hr;
if (m_ValidateInProgress)
{
hr = E_FAIL;
}
else
{
NotificationListener nl;
nl.listener = pListener;
nl.notificationType = mask;
hr = m_Listeners.Add(nl);
if (SUCCEEDED(hr))
{
if (mask & SOCT_OBJECT_ADD)
{
hr = m_NewTopologyListeners.Add(pListener);
}
}
}
return hr;
}
void RChannelReaderImpl::
ProcessItemArrayRequest(RChannelProcessRequest* request)
{
RChannelItemArray* itemArray = request->GetItemArray();
RChannelItemArrayReaderHandler* handler = request->GetHandler();
LogAssert(handler != NULL);
LogAssert(itemArray != NULL);
void* cancelCookie = request->GetCookie();
handler->ProcessItemArray(itemArray);
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_state != RS_Stopped);
/* now that the request has been processed remove it from our
accounting */
RemoveFromCancelMap(request, cancelCookie);
/* if it was the last request with this cookie and somebody
was blocked cancelling the cookie, wake them up */
MaybeTriggerCancelEvent(cancelCookie);
/* if it was the last request in the system and we are
draining, wake up the drain thread */
if (m_state == RS_Stopping && m_cookieMap.empty())
{
LogAssert(m_eventMap.empty());
BOOL bRet = ::SetEvent(m_drainEvent);
LogAssert(bRet != 0);
}
}
}
bool FindModuleString(
int nCode,
const wchar_t* szwModule,
AKWSTR& wstrString,
bool bLoc)
{
szwModule = KLSTD::FixNullString(szwModule);
AutoCriticalSection acs(KLERR::g_pModulesCS);
try
{
modules_t* pModules = GetModulesCS(bLoc);
KLSTD_ASSERT(pModules);
if(!pModules)
return false;
modules_t::iterator it = pModules->find(szwModule);
if( it != pModules->end())
{
KLERR::strings_t::iterator it2=it->second->find(nCode);
if(it2!=it->second->end())
{
wstrString = KLSTD::klwstr_t(it2->second).detach();
return true;
};
};
}
catch(std::exception& err)
{
KLERR_TRACE_UNEXPECTED();
};
return false;
};
void RChannelFifoNBWriter::Start()
{
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_writerState == WS_Stopped);
LogAssert(m_outstandingUnits == 0);
LogAssert(m_blockedList.IsEmpty());
LogAssert(m_reader != NULL);
LogAssert(m_nextDataSequenceNumber == 0);
LogAssert(m_nextDeliverySequenceNumber == 0);
m_sendLatch.Start();
m_returnLatch.Start();
m_writerTerminationItem = NULL;
m_readerTerminationItem = NULL;
m_numberOfSubItemsWritten = 0;
m_dataSizeWritten = 0;
LogAssert(m_supplierEpoch == m_writerEpoch);
m_writerState = WS_Running;
}
}
KLSTD_NOTHROW const wchar_t* CError::GetLocModuleName() throw()
{
KLSTD::AutoCriticalSection acs(g_pErrorCS);
return ( !m_pLocInfo )
? GetModuleName()
: m_pLocInfo->m_wstrLocModule.c_str();
};
void RChannelFifoWriterBase::CloseSupplier()
{
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_supplierState == SS_Stopped);
m_supplierState = SS_Closed;
}
}
/**
@todo JSON access errors lack specifier
@todo Check that omegas ar filled/exits
@todo Clean up nested checks for optional JSON arguments
@todo Eigenvalues should be computed independent of json output,
stored and used twice, for screen and file
*/
void run(const Settings &s) {
// empty configurators
unique_ptr<csmp::tperm::Configurator> mconf =
make_unique<csmp::tperm::NullConfigurator>();
unique_ptr<csmp::tperm::Configurator> fconf =
make_unique<csmp::tperm::NullConfigurator>();
// get matrix configurator
Settings cs(s, "configuration");
if (cs.json.count("matrix")) {
Settings mcs(cs, "matrix");
mconf = MatrixConfiguratorFactory().configurator(mcs);
}
// get fracture configurator
if (cs.json.count("fractures")) {
Settings fcs(cs, "fractures");
fconf = FractureConfiguratorFactory().configurator(fcs);
}
// get omega generator
Settings acs(s, "analysis");
auto ogen = make_omega_generator(acs);
// load model...
Settings ms(s, "model");
auto model = load_model(ms);
// configure material properties
mconf->configure(*model);
fconf->configure(*model);
// sort boundaries
auto bds = sort_boundaries(*model, s);
// ready to solve
solve(bds, *model);
// generate omegas
auto omegas = ogen->generate(*model);
auto nomegas = named_omegas(omegas);
// get upscaled tensors
auto omega_tensors = fetch(*model, nomegas);
// results
string jres_fname = "";
if (s.json.count("output")) {
Settings outs(s, "output");
if (outs.json.count("save final binary")) // write to csmp binary
if (outs.json["save final binary"].get<string>() != "")
save_model(*model,
outs.json["save final binary"].get<string>().c_str());
if (outs.json.count("vtu")) { // write to vtu
if (outs.json["vtu"].get<bool>()) {
make_omega_regions(nomegas, *model);
vtu(omega_tensors, *model);
}
if (outs.json.count("vtu regions"))
vtu(outs.json["vtu regions"].get<vector<string>>(), *model);
}
if (outs.json.count("results file name")) // write to json
jres_fname = s.json["output"]["results file name"].get<string>();
}
report(omega_tensors, *model, jres_fname.c_str());
}
KLSTD_NOTHROW bool CError::Clone(KLERR::Error2** ppError) throw()
{
KLSTD_ASSERT(ppError && !(*ppError));
KLSTD::AutoCriticalSection acs(g_pErrorCS);
KLERR::Error2Ptr pResult;
KLERR::CError* pNew = new CError(*this);
pResult.Attach( static_cast<KLERR::Error2*>(pNew) );
pResult.CopyTo(ppError);
return !!pResult;
};
void RChannelReaderImpl::
ThreadSafeSetItemArray(RChannelItemArrayRef* dstItemArray,
RChannelItemArray* srcItemArray)
{
{
AutoCriticalSection acs(&m_baseDR);
dstItemArray->Set(srcItemArray);
}
}
KLSTD_NOTHROW void CError::GetPreviousError2(KLERR::Error2** ppError) throw()
{
KLSTD::AutoCriticalSection acs(g_pErrorCS);
if(ppError && !(*ppError) && m_pParentError)
{
KLSTD::CAutoPtr<KLERR::Error2> pRes;
pRes = ErrAdapt(m_pParentError);
pRes.CopyTo(ppError);
};
};
void RChannelFifoWriter::GetTerminationItems(RChannelItemRef* pWriterDrainItem,
RChannelItemRef* pReaderDrainItem)
{
{
AutoCriticalSection acs(&m_baseDR);
*pWriterDrainItem = m_writerTerminationItem;
*pReaderDrainItem = m_readerTerminationItem;
}
}
void RChannelFifoWriter::DrainSupplier(RChannelItem* drainItem)
{
ChannelFifoUnitList returnList;
bool wakeUpWriterDrain = false;
bool wakeUpSupplierDrain = false;
bool waitForSupplierDrain = false;
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_supplierState == SS_Interrupted);
LogAssert(m_availableUnits == 0);
LogAssert(drainItem != NULL);
RChannelItemType drainType = drainItem->GetType();
m_readerTerminationItem = drainItem;
if (m_outstandingUnits > 0)
{
m_supplierState = SS_Draining;
waitForSupplierDrain = true;
}
else
{
wakeUpWriterDrain = ReWriteBlockedListForEarlyReturn(drainType);
returnList.TransitionToTail(&m_blockedList);
m_returnLatch.AcceptList(&returnList);
m_supplierState = SS_Stopped;
++m_supplierEpoch;
wakeUpSupplierDrain = true;
}
}
if (wakeUpWriterDrain)
{
BOOL bRet = ::SetEvent(m_writerDrainEvent);
LogAssert(bRet != 0);
}
if (wakeUpSupplierDrain)
{
LogAssert(waitForSupplierDrain == false);
BOOL bRet = ::SetEvent(m_supplierDrainEvent);
LogAssert(bRet != 0);
}
else if (waitForSupplierDrain)
{
DWORD dRet = ::WaitForSingleObject(m_supplierDrainEvent, INFINITE);
LogAssert(dRet == WAIT_OBJECT_0);
}
ReturnHandlers(&returnList);
}
extern void
tty_print_alt_char(int c)
{
#ifdef HAVE_SLANG
SLsmg_draw_object(SLsmg_get_row(), SLsmg_get_column(), c);
#else
acs();
addch(c);
noacs();
#endif
}
void RChannelFifoWriterBase::Close()
{
{
AutoCriticalSection acs(&m_baseDR);
LogAssert(m_writerState == WS_Stopped);
m_writerState = WS_Closed;
m_writerTerminationItem = NULL;
m_readerTerminationItem = NULL;
}
}
KLSTD_NOTHROW const wchar_t* CError::LocGetPar(size_t nIndex)throw()
{
KLSTD::AutoCriticalSection acs(g_pErrorCS);
return ( nIndex < 1 ||
nIndex > c_nMaxArgs ||
!m_pLocInfo ||
m_pLocInfo->m_vecArgs.size() < nIndex
)
? L""
: m_pLocInfo->m_vecArgs[nIndex-1].c_str();
};
KLSTD_NOTHROW bool CError::IsLocalized() throw()
{
KLSTD::AutoCriticalSection acs(g_pErrorCS);
return ( m_pLocInfo &&
( m_pLocInfo->m_nFormat ||
!m_pLocInfo->m_wstrFormat.empty()
)
)
? true
: false;
};
bool RChannelReaderImpl::IsRunning()
{
bool retval;
{
AutoCriticalSection acs(&m_baseDR);
retval = (m_state == RS_Running);
}
return retval;
}
HRESULT SceneGraph::RegisterForValidate(__in ISceneObject *pObject)
{
if (!pObject)
return E_INVALIDARG;
AutoCriticalSection acs(m_Validation);
if (m_ValidateInProgress)
return E_FAIL;
return m_InvalidObjects.Add(pObject);
}
