void rates_queue::processQueue()
{
if (!pendingList)
return;
if (!ppro->icqOnline())
{
cleanup();
return;
}
// take from queue, execute
rates_queue_item *item = pendingList[0];
ppro->m_ratesMutex->Enter();
listsMutex->Enter();
if (item->isOverRate(limitLevel))
{ // the rate is higher, keep sleeping
int nDelay = ppro->m_rates->getDelayToLimitLevel(item->wGroup, ppro->m_rates->getLimitLevel(item->wGroup, waitLevel));
listsMutex->Leave();
ppro->m_ratesMutex->Leave();
if (nDelay < 10) nDelay = 10;
initDelay(nDelay, &rates_queue::processQueue);
return;
}
ppro->m_ratesMutex->Leave();
if (pendingListSize > 1)
{ // we need to keep order
memmove(&pendingList[0], &pendingList[1], (pendingListSize - 1) * sizeof(rates_queue_item*));
}
else
SAFE_FREE((void**)&pendingList);
int bSetupTimer = --pendingListSize != 0;
listsMutex->Leave();
if (ppro->icqOnline())
{
ppro->NetLog_Server("Rates: Resuming %s.", szDescr);
item->execute();
}
else
ppro->NetLog_Server("Rates: Discarding %s.", szDescr);
if (bSetupTimer)
{
// in queue remained some items, setup timer
ppro->m_ratesMutex->Enter();
int nDelay = ppro->m_rates->getDelayToLimitLevel(item->wGroup, waitLevel);
ppro->m_ratesMutex->Leave();
if (nDelay < 10) nDelay = 10;
initDelay(nDelay, &rates_queue::processQueue);
}
SAFE_DELETE((void_struct**)&item);
}
int main()
{
initDelay();
P1_0 = 0;
while(1)
{
delay(1000);
P1_0 = ! P1_0;
}
return 0;
}
void rates_queue::putItem(rates_queue_item *pItem, int nMinDelay)
{
int bFound = FALSE;
if (!ppro->icqOnline())
return;
ppro->NetLog_Server("Rates: Delaying %s.", szDescr);
listsMutex->Enter();
if (pendingListSize)
{
for (int i = 0; i < pendingListSize; i++)
{
if (pendingList[i]->isEqual(pItem))
{
if (duplicates == -1)
{ // discard existing, append new item
SAFE_DELETE((void_struct**)&pendingList[i]);
memcpy(&pendingList[i], &pendingList[i + 1], (pendingListSize - i - 1) * sizeof(rates_queue_item*));
bFound = TRUE;
}
else if (duplicates == 1)
{ // keep existing, ignore new
listsMutex->Leave();
return;
}
// otherwise keep existing and append new
}
}
}
if (!bFound)
{ // not found, enlarge the queue
pendingListSize++;
pendingList = (rates_queue_item**)SAFE_REALLOC(pendingList, pendingListSize * sizeof(rates_queue_item*));
}
pendingList[pendingListSize - 1] = pItem->copyItem();
if (pendingListSize == 1)
{ // queue was empty setup timer
listsMutex->Leave();
ppro->m_ratesMutex->Enter();
int nDelay = ppro->m_rates->getDelayToLimitLevel(pItem->wGroup, waitLevel);
ppro->m_ratesMutex->Leave();
if (nDelay < 10) nDelay = 10;
if (nDelay < nMinDelay) nDelay = nMinDelay;
initDelay(nDelay, &rates_queue::processQueue);
}
else
listsMutex->Leave();
}
fmiStatus fmiInitialize(fmiComponent c, fmiBoolean toleranceControlled, fmiReal relativeTolerance, fmiEventInfo* eventInfo)
{
double nextSampleEvent=0;
ModelInstance* comp = (ModelInstance *)c;
threadData_t *threadData = comp->threadData;
threadData->currentErrorStage = ERROR_SIMULATION;
if (invalidState(comp, "fmiInitialize", modelInstantiated))
return fmiError;
if (nullPointer(comp, "fmiInitialize", "eventInfo", eventInfo))
return fmiError;
if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
"fmiInitialize: toleranceControlled=%d relativeTolerance=%g",
toleranceControlled, relativeTolerance);
/* set zero-crossing tolerance */
setZCtol(relativeTolerance);
setStartValues(comp);
copyStartValuestoInitValues(comp->fmuData);
/* try */
MMC_TRY_INTERNAL(simulationJumpBuffer)
if(initialization(comp->fmuData, comp->threadData, "", "", 0.0, 5))
{
comp->state = modelError;
if(comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
"fmiInitialization: failed");
}
else
{
comp->state = modelInitialized;
if(comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
"fmiInitialization: succeed");
}
/*TODO: Simulation stop time is need to calculate in before hand all sample events
We shouldn't generate them all in beforehand */
initSample(comp->fmuData, comp->threadData, comp->fmuData->localData[0]->timeValue, 100 /*should be stopTime*/);
initDelay(comp->fmuData, comp->fmuData->localData[0]->timeValue);
/* due to an event overwrite old values */
overwriteOldSimulationData(comp->fmuData);
eventInfo->iterationConverged = fmiTrue;
eventInfo->stateValueReferencesChanged = fmiFalse;
eventInfo->stateValuesChanged = fmiTrue;
eventInfo->terminateSimulation = fmiFalse;
/* Get next event time (sample calls)*/
nextSampleEvent = getNextSampleTimeFMU(comp->fmuData);
if (nextSampleEvent == -1){
eventInfo->upcomingTimeEvent = fmiFalse;
}else{
eventInfo->upcomingTimeEvent = fmiTrue;
eventInfo->nextEventTime = nextSampleEvent;
fmiEventUpdate(comp, fmiFalse, eventInfo);
}
return fmiOK;
/* catch */
MMC_CATCH_INTERNAL(simulationJumpBuffer)
comp->functions.logger(c, comp->instanceName, fmiError, "error", "fmiInitialize: terminated by an assertion.");
return fmiError;
}
/*! \fn static int symbolic_initialization(DATA *data)
*
* \param [ref] [data]
*
* \author lochel
*/
static int symbolic_initialization(DATA *data, threadData_t *threadData, long numLambdaSteps)
{
TRACE_PUSH
long step;
int retVal;
/* initial sample and delay before initial the system */
initDelay(data, data->simulationInfo->startTime);
/* initialize all relations that are ZeroCrossings */
storePreValues(data);
overwriteOldSimulationData(data);
if (data->callback->useHomotopy && numLambdaSteps > 1)
{
long i;
char buffer[4096];
FILE *pFile = NULL;
modelica_real* realVars = (modelica_real*)calloc(data->modelData->nVariablesReal, sizeof(modelica_real));
modelica_integer* integerVars = (modelica_integer*)calloc(data->modelData->nVariablesInteger, sizeof(modelica_integer));
modelica_boolean* booleanVars = (modelica_boolean*)calloc(data->modelData->nVariablesBoolean, sizeof(modelica_boolean));
modelica_string* stringVars = (modelica_string*) omc_alloc_interface.malloc_uncollectable(data->modelData->nVariablesString * sizeof(modelica_string));
MODEL_DATA *mData = data->modelData;
assertStreamPrint(threadData, 0 != realVars, "out of memory");
assertStreamPrint(threadData, 0 != integerVars, "out of memory");
assertStreamPrint(threadData, 0 != booleanVars, "out of memory");
assertStreamPrint(threadData, 0 != stringVars, "out of memory");
for(i=0; i<mData->nVariablesReal; ++i) {
realVars[i] = mData->realVarsData[i].attribute.start;
}
for(i=0; i<mData->nVariablesInteger; ++i) {
integerVars[i] = mData->integerVarsData[i].attribute.start;
}
for(i=0; i<mData->nVariablesBoolean; ++i) {
booleanVars[i] = mData->booleanVarsData[i].attribute.start;
}
for(i=0; i<mData->nVariablesString; ++i) {
stringVars[i] = mData->stringVarsData[i].attribute.start;
}
if(ACTIVE_STREAM(LOG_INIT))
{
sprintf(buffer, "%s_homotopy.csv", mData->modelFilePrefix);
pFile = fopen(buffer, "wt");
fprintf(pFile, "%s,", "lambda");
for(i=0; i<mData->nVariablesReal; ++i)
fprintf(pFile, "%s,", mData->realVarsData[i].info.name);
fprintf(pFile, "\n");
}
infoStreamPrint(LOG_INIT, 1, "homotopy process");
for(step=0; step<numLambdaSteps; ++step)
{
data->simulationInfo->lambda = ((double)step)/(numLambdaSteps-1);
if(data->simulationInfo->lambda > 1.0) {
data->simulationInfo->lambda = 1.0;
}
if(0 == step)
data->callback->functionInitialEquations_lambda0(data, threadData);
else
data->callback->functionInitialEquations(data, threadData);
infoStreamPrint(LOG_INIT, 0, "lambda = %g done", data->simulationInfo->lambda);
if(ACTIVE_STREAM(LOG_INIT))
{
fprintf(pFile, "%.16g,", data->simulationInfo->lambda);
for(i=0; i<mData->nVariablesReal; ++i)
fprintf(pFile, "%.16g,", data->localData[0]->realVars[i]);
fprintf(pFile, "\n");
}
if(check_nonlinear_solutions(data, 0) ||
check_linear_solutions(data, 0) ||
check_mixed_solutions(data, 0))
break;
setAllStartToVars(data);
}
messageClose(LOG_INIT);
if(ACTIVE_STREAM(LOG_INIT))
fclose(pFile);
for(i=0; i<mData->nVariablesReal; ++i)
mData->realVarsData[i].attribute.start = realVars[i];
for(i=0; i<mData->nVariablesInteger; ++i)
mData->integerVarsData[i].attribute.start = integerVars[i];
for(i=0; i<mData->nVariablesBoolean; ++i)
mData->booleanVarsData[i].attribute.start = booleanVars[i];
for(i=0; i<mData->nVariablesString; ++i)
mData->stringVarsData[i].attribute.start = stringVars[i];
free(realVars);
free(integerVars);
free(booleanVars);
omc_alloc_interface.free_uncollectable(stringVars);
}
else
{
data->simulationInfo->lambda = 1.0;
data->callback->functionInitialEquations(data, threadData);
}
storeRelations(data);
/* check for over-determined systems */
retVal = data->callback->functionRemovedInitialEquations(data, threadData);
TRACE_POP
return retVal;
}
