/**
Add a variable occurency to variable group
*/
Variable * insertVariable(Variable * v_root, char * name, int line)
{
int cmp;
Line * nl;
if (v_root == NULL)
{
v_root = newVariable(name);
v_root->last_line = newLine(line);
}
else
if ((cmp = strcmp(name, v_root->name)) == 0)
{
v_root->count++;
if (line == v_root->last_line->number)
v_root->last_line->count++;
else
{
nl = newLine(line);
nl->prev = v_root->last_line;
v_root->last_line = nl;
}
}
else
if (cmp > 0)
v_root->right = insertVariable(v_root->right, name, line);
else
v_root->left = insertVariable(v_root->left, name, line);
return v_root;
}
Variable Object::CreateVariable(const NodeId& newVariableId, const QualifiedName& browseName, const Variant& value)
{
// Creating new node for object
AddNodesItem newNodeRequest;
newNodeRequest.BrowseName = browseName;
newNodeRequest.RequestedNewNodeId = newVariableId;
newNodeRequest.Class = NodeClass::Variable;
newNodeRequest.ParentNodeId = GetId();
newNodeRequest.ReferenceTypeId = ObjectId::HasProperty;
newNodeRequest.TypeDefinition = NodeId();
VariableAttributes attrs;
attrs.Description = LocalizedText(browseName.Name);
attrs.DisplayName = LocalizedText(browseName.Name);
attrs.Value = value;
attrs.Type = OpcUa::VariantTypeToDataType(value.Type());
newNodeRequest.Attributes = attrs;
NodeManagementServices::SharedPtr nodes = GetServices()->NodeManagement();
std::vector<AddNodesResult> newNode = nodes->AddNodes({newNodeRequest});
if (newNode.size() != 1)
{
throw std::runtime_error("opcua_model| Server returned wrong number new nodes results.");
}
OpcUa::CheckStatusCode(newNode[0].Status);
Variable newVariable(GetServices());
newVariable.Id = newNode[0].AddedNodeId;
newVariable.BrowseName = browseName;
newVariable.DisplayName = attrs.Description;
newVariable.DataType = value.Type();
newVariable.TypeId = newNodeRequest.TypeDefinition;
return newVariable;
}
BDHServerController::BDHServerController(QObject *parent)
:QObject(parent)
{
m_dataStorage = new SQLiteDatabase(this);
m_ahpServer = new AHP::AHPServer(this,this);
m_dataAcquisition = new DataAcquisition(this);
m_realtimeCache = new RealtimeCache(this);
m_collectorInterface = nullptr;
m_configurationLoader = new XmlLoader(this);
m_alarmCounter = 0;
m_myIP = selectHostAddress().toString();
m_myPort = 9999;
connect(this,SIGNAL(newVariablePoint(quint32,quint8,qulonglong,QVariant)),m_realtimeCache,SLOT(storeVariablePoint(quint32,quint8,quint64,QVariant)));
//! Acquisition Simulation
connect(m_dataAcquisition,SIGNAL(incommingAlarmPoint(quint32,AlarmState,quint64)),m_dataStorage,SLOT(storeIncommingAlarmPoint(quint32,AlarmState,quint64)));
connect(m_dataAcquisition,SIGNAL(incommingVariablePoint(quint32,quint8,quint64,QVariant)),m_realtimeCache,SLOT(storeVariablePoint(quint32,quint8,quint64,QVariant)));
//! Connection between RealtimeCache and SQLiteDatabase to persist data
connect(m_realtimeCache,SIGNAL(persistData(quint32,quint8,quint64,QVariant)),m_dataStorage,SLOT(storeIncommingVariablePoint(quint32,quint8,quint64,QVariant)));
//! Configuration connects
connect(m_configurationLoader,SIGNAL(loadFinished()),SLOT(configurationLoadFinish()));
connect(m_configurationLoader,SIGNAL(newCollector(QXmlAttributes)),this,SLOT(addConfigurationCollector(QXmlAttributes)));
connect(m_configurationLoader,SIGNAL(newVariable(QXmlAttributes)),this,SLOT(addConfigurationVariable(QXmlAttributes)));
connect(m_configurationLoader,SIGNAL(newAlarm(QXmlAttributes)),this,SLOT(addConfigurationAlarm(QXmlAttributes)));
connect(m_configurationLoader,SIGNAL(newBDH(QXmlAttributes)),this,SLOT(addConfigurationBDH(QXmlAttributes)));
}
void REGISTER_PRIMITIVE(Cons* env, char* name, LITHP_FUNCTION function, int special)
{
newVariable(env, name, NEW_PRIMITIVE_ATOM(function, special));
}
int
OPTquerylogImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i, limit, slimit;
InstrPtr p = 0, *old= mb->stmt, q,r;
int argc, io, user,nice,sys,idle,iowait,load, arg, start,finish, name;
int xtime=0, rtime = 0, tuples=0;
InstrPtr defineQuery = NULL;
// query log needed?
if ( !QLOGisset() )
return 0;
(void) pci;
(void) stk; /* to fool compilers */
(void) cntxt;
/* gather information */
for (i = 1; i < mb->stop; i++) {
p = getInstrPtr(mb,i);
if ( getModuleId(p) && idcmp(getModuleId(p), "querylog") == 0 && idcmp(getFunctionId(p),"define")==0){
defineQuery= p;
getVarConstant(mb,getArg(p,3)).val.lval = GDKusec()-getVarConstant(mb,getArg(p,3)).val.lval ;
}
}
if ( defineQuery == NULL)
/* nothing to do */
return 0;
limit= mb->stop;
slimit= mb->ssize;
if ( newMalBlkStmt(mb, mb->ssize) < 0)
return 0;
pushInstruction(mb, old[0]);
/* run the querylog.define operation */
defineQuery = copyInstruction(defineQuery);
setFunctionId(defineQuery, insertRef);
getArg(defineQuery,0) = newTmpVariable(mb,TYPE_any);
defineQuery->token = ASSIGNsymbol;
setModuleId(defineQuery,querylogRef);
/* collect the initial statistics */
q = newStmt(mb, "clients", "getUsername");
name= getArg(q,0)= newVariable(mb,GDKstrdup("name"),TYPE_str);
defineQuery = pushArgument(mb,defineQuery,name);
q = newStmt(mb, "mtime", "current_timestamp");
start= getArg(q,0)= newVariable(mb,GDKstrdup("start"),TYPE_timestamp);
defineQuery = pushArgument(mb,defineQuery,start);
pushInstruction(mb, defineQuery);
q = newStmt1(mb, sqlRef, "argRecord");
for ( argc=1; argc < old[0]->argc; argc++)
q = pushArgument(mb, q, getArg(old[0],argc));
arg= getArg(q,0)= newVariable(mb,GDKstrdup("args"),TYPE_str);
q = newStmt(mb, "alarm", "usec");
xtime = getArg(q,0)= newVariable(mb,GDKstrdup("xtime"),TYPE_lng);
user = newVariable(mb,GDKstrdup("user"),TYPE_lng);
nice = newVariable(mb,GDKstrdup("nice"),TYPE_lng);
sys = newVariable(mb,GDKstrdup("sys"),TYPE_lng);
idle = newVariable(mb,GDKstrdup("idle"),TYPE_lng);
iowait = newVariable(mb,GDKstrdup("iowait"),TYPE_lng);
q = newStmt(mb, "profiler", "cpustats");
q->retc= q->argc =0;
q = pushReturn(mb,q,user);
q = pushReturn(mb,q,nice);
q = pushReturn(mb,q,sys);
q = pushReturn(mb,q,idle);
q = pushReturn(mb,q,iowait);
q = newAssignment(mb);
tuples= getArg(q,0) = newVariable(mb,GDKstrdup("tuples"),TYPE_wrd);
(void) pushWrd(mb,q,1);
for (i = 1; i < limit; i++) {
p = old[i];
if (getModuleId(p)==sqlRef &&
(idcmp(getFunctionId(p),"exportValue")==0 ||
idcmp(getFunctionId(p),"exportResult")==0 ) ) {
q = newStmt(mb, "alarm", "usec");
r = newStmt1(mb, calcRef, "-");
r = pushArgument(mb, r, getArg(q,0));
r = pushArgument(mb, r, xtime);
getArg(r,0)=xtime;
q = newStmt(mb, "alarm", "usec");
rtime= getArg(q,0)= newVariable(mb,GDKstrdup("rtime"),TYPE_lng);
pushInstruction(mb,p);
continue;
}
if ( getModuleId(p) == sqlRef && idcmp(getFunctionId(p),"resultSet")==0 && isaBatType(getVarType(mb,getArg(p,3)))){
q = newStmt(mb, "aggr", "count");
getArg(q,0) = tuples;
(void) pushArgument(mb,q, getArg(p,3));
pushInstruction(mb,p);
continue;
}
if ( p->token== ENDsymbol || p->barrier == RETURNsymbol || p->barrier == YIELDsymbol){
if ( rtime == 0){
q = newStmt(mb, "alarm", "usec");
r = newStmt1(mb, calcRef, "-");
r = pushArgument(mb, r, getArg(q,0));
r = pushArgument(mb, r, xtime);
getArg(r,0)=xtime;
q = newStmt(mb, "alarm", "usec");
rtime= getArg(q,0)= newVariable(mb,GDKstrdup("rtime"),TYPE_lng);
}
q = newStmt(mb, "alarm", "usec");
r = newStmt1(mb, calcRef, "-");
r = pushArgument(mb, r, getArg(q,0));
r = pushArgument(mb, r, rtime);
getArg(r,0)=rtime;
/*
* Post execution statistics gathering
*/
q = newStmt(mb, "mtime", "current_timestamp");
finish= getArg(q,0)= newVariable(mb,GDKstrdup("finish"),TYPE_any);
q = newStmt(mb, "profiler", "cpuload");
load = newVariable(mb,GDKstrdup("load"),TYPE_int);
getArg(q,0)= load;
io = newVariable(mb,GDKstrdup("io"),TYPE_int);
q= pushReturn(mb,q,io);
q = pushArgument(mb,q,user);
q = pushArgument(mb,q,nice);
q = pushArgument(mb,q,sys);
q = pushArgument(mb,q,idle);
q = pushArgument(mb,q,iowait);
q = newStmt(mb, querylogRef, "call");
q = pushArgument(mb, q, start);
q = pushArgument(mb, q, finish);
q = pushArgument(mb, q, arg);
q = pushArgument(mb, q, tuples);
q = pushArgument(mb, q, xtime);
q = pushArgument(mb, q, rtime);
q = pushArgument(mb, q, load);
q = pushArgument(mb, q, io);
pushInstruction(mb,p);
continue;
}
pushInstruction(mb,p);
if (p->barrier == YIELDsymbol){
/* the factory yield may return */
q = newStmt(mb, "mtime", "current_timestamp");
start= getArg(q,0)= newVariable(mb,GDKstrdup("start"),TYPE_any);
q = newStmt1(mb, sqlRef, "argRecord");
for ( argc=1; argc < old[0]->argc; argc++)
q = pushArgument(mb, q, getArg(old[0],argc));
arg= getArg(q,0)= newVariable(mb,GDKstrdup("args"),TYPE_str);
q = newAssignment(mb);
q = pushLng(mb,q,0);
q = newAssignment(mb);
q = pushWrd(mb,q,0);
tuples= getArg(q,0)= newVariable(mb,GDKstrdup("tuples"),TYPE_wrd);
newFcnCall(mb,"profiler","setMemoryFlag");
q->argc--;
pushWrd(mb,q,1);
q = newStmt(mb, "alarm", "usec");
xtime = getArg(q,0)= newVariable(mb,GDKstrdup("xtime"),TYPE_lng);
}
}
for( ; i<slimit; i++)
if(old[i])
freeInstruction(old[i]);
GDKfree(old);
return 1;
}
/*
* Set up environment and global constraints (dir-edge constraints, containment constraints
* etc).
*
* diredges: 0=no dir edge constraints
* 1=one separation constraint for each edge (in acyclic subgraph)
* 2=DiG-CoLa level constraints
*/
CMajEnvVPSC *initCMajVPSC(int n, float *packedMat, vtx_data * graph,
ipsep_options * opt, int diredges)
{
int i, j;
/* nv is the number of real nodes */
int nConCs;
/* fprintf(stderr,"Entered initCMajVPSC\n"); */
CMajEnvVPSC *e = GNEW(CMajEnvVPSC);
e->A = NULL;
e->packedMat = packedMat;
/* if we have clusters then we'll need two constraints for each var in
* a cluster */
e->nldv = 2 * opt->clusters->nclusters;
e->nv = n - e->nldv;
e->ndv = 0;
e->gcs = NULL;
e->vs = N_GNEW(n, Variable *);
for (i = 0; i < n; i++) {
e->vs[i] = newVariable(i, 1.0, 1.0);
}
e->gm = 0;
if (diredges == 1) {
if (Verbose)
fprintf(stderr, " generate edge constraints...\n");
for (i = 0; i < e->nv; i++) {
for (j = 1; j < graph[i].nedges; j++) {
/* fprintf(stderr,"edist=%f\n",graph[i].edists[j]); */
if (graph[i].edists[j] > 0.01) {
e->gm++;
}
}
}
e->gcs = newConstraints(e->gm);
e->gm = 0;
for (i = 0; i < e->nv; i++) {
for (j = 1; j < graph[i].nedges; j++) {
int u = i, v = graph[i].edges[j];
if (graph[i].edists[j] > 0) {
e->gcs[e->gm++] =
newConstraint(e->vs[u], e->vs[v], opt->edge_gap);
}
}
}
} else if (diredges == 2) {
int *ordering = NULL, *ls = NULL, cvar;
double halfgap;
DigColaLevel *levels;
Variable **vs = e->vs;
/* e->ndv is the number of dummy variables required, one for each boundary */
if (compute_hierarchy(graph, e->nv, 1e-2, 1e-1, NULL, &ordering, &ls,
&e->ndv)) return NULL;
levels = assign_digcola_levels(ordering, e->nv, ls, e->ndv);
if (Verbose)
fprintf(stderr, "Found %d DiG-CoLa boundaries\n", e->ndv);
e->gm =
get_num_digcola_constraints(levels, e->ndv + 1) + e->ndv - 1;
e->gcs = newConstraints(e->gm);
e->gm = 0;
e->vs = N_GNEW(n + e->ndv, Variable *);
for (i = 0; i < n; i++) {
e->vs[i] = vs[i];
}
free(vs);
/* create dummy vars */
for (i = 0; i < e->ndv; i++) {
/* dummy vars should have 0 weight */
cvar = n + i;
e->vs[cvar] = newVariable(cvar, 1.0, 0.000001);
}
halfgap = opt->edge_gap;
for (i = 0; i < e->ndv; i++) {
cvar = n + i;
/* outgoing constraints for each var in level below boundary */
for (j = 0; j < levels[i].num_nodes; j++) {
e->gcs[e->gm++] =
newConstraint(e->vs[levels[i].nodes[j]], e->vs[cvar],
halfgap);
}
/* incoming constraints for each var in level above boundary */
for (j = 0; j < levels[i + 1].num_nodes; j++) {
e->gcs[e->gm++] =
newConstraint(e->vs[cvar],
e->vs[levels[i + 1].nodes[j]], halfgap);
}
}
/* constraints between adjacent boundary dummy vars */
for (i = 0; i < e->ndv - 1; i++) {
e->gcs[e->gm++] =
newConstraint(e->vs[n + i], e->vs[n + i + 1], 0);
}
}
int
inlineMALblock(MalBlkPtr mb, int pc, MalBlkPtr mc)
{
int i, k, l, n;
InstrPtr *ns, p,q;
int *nv, *np = NULL;
p = getInstrPtr(mb, pc);
q = getInstrPtr(mc, 0);
ns = GDKzalloc((l = (mb->ssize + mc->ssize + p->retc - 3)) * sizeof(InstrPtr));
if (ns == NULL)
return -1;
if ( mc->ptop > 0){
np = (int*) GDKmalloc(mc->ptop * sizeof(int));
if (np == 0){
GDKfree(ns);
return -1;
}
}
nv = (int*) GDKmalloc(mc->vtop * sizeof(int));
if (nv == 0){
GDKfree(ns);
if( np)
GDKfree(np);
return -1;
}
/* add all properties of the new block to the target environment */
for (n = 0; n < mc->ptop; n++) {
int propid = newProperty(mb);
if (propid < 0) {
assert(0);
return -1;
}
np[n] = propid;
mb->prps[propid].idx = mc->prps[n].idx;
mb->prps[propid].op = mc->prps[n].op;
mb->prps[propid].var = mc->prps[n].var; /* fixed later */
}
/* add all variables of the new block to the target environment */
for (n = 0; n < mc->vtop; n++) {
VarPtr ov, v;
if (isExceptionVariable(mc->var[n]->name)) {
nv[n] = newVariable(mb,GDKstrdup(mc->var[n]->name),TYPE_str);
if (isVarUDFtype(mc,n))
setVarUDFtype(mb,nv[n]);
if (isVarUsed(mc,n))
setVarUsed(mb,nv[n]);
} else if (isVarTypedef(mc,n)) {
nv[n] = newTypeVariable(mb,getVarType(mc,n));
} else if (isVarConstant(mc,n)) {
nv[n] = cpyConstant(mb,getVar(mc,n));
} else {
nv[n] = newTmpVariable(mb, getVarType(mc, n));
if (isVarUDFtype(mc,n))
setVarUDFtype(mb,nv[n]);
if (isVarUsed(mc,n))
setVarUsed(mb,nv[n]);
}
/* remap the properties */
ov = getVar(mc, n);
v = getVar(mb, nv[n]);
if (ov->propc > v->maxprop) {
int size = sizeof(VarRecord);
VarPtr vnew = (VarPtr) GDKzalloc(size + ov->propc * sizeof(int));
memcpy((char*) vnew, (char*) v, size);
vnew->maxprop = ov->propc;
mb->var[nv[n]] = vnew;
GDKfree(v);
v = getVar(mb, nv[n]);
}
for (i = 0; i < ov->propc; i++)
v->prps[i] = np[ov->prps[i]];
v->propc = ov->propc;
}
/* change the property variables to the new context */
for (n = 0; n < mc->ptop; n++) {
if (mc->prps[n].var)
mb->prps[np[n]].var = nv[mc->prps[n].var];
assert( mb->prps[np[n]].var >= 0);
}
/* use an alias mapping to keep track of the actual arguments */
for (n = p->retc; n < p->argc; n++)
nv[getArg(q,n)] = getArg(p, n);
k = 0;
/* find the return statement of the inline function */
for (i = 1; i < mc->stop - 1; i++) {
q = mc->stmt[i];
if( q->barrier== RETURNsymbol || q->barrier== YIELDsymbol){
/* add the mapping of the return variables */
for(n=0; n<p->retc; n++)
nv[getArg(q,n)] = getArg(p,n);
}
}
/* copy the stable part */
for (i = 0; i < pc; i++)
ns[k++] = mb->stmt[i];
for (i = 1; i < mc->stop - 1; i++) {
q = mc->stmt[i];
if( q->token == ENDsymbol)
break;
/* copy the instruction and fix variable references */
ns[k] = copyInstruction(q);
for (n = 0; n < q->argc; n++)
getArg(ns[k], n) = nv[getArg(q, n)];
if (q->barrier == RETURNsymbol || q->barrier == YIELDsymbol) {
for(n=0; n<q->retc; n++)
clrVarFixed(mb,getArg(ns[k],n)); /* for typing */
setModuleId(ns[k],getModuleId(q));
setFunctionId(ns[k],getFunctionId(q));
ns[k]->barrier = 0;
ns[k]->token = ASSIGNsymbol;
}
k++;
}
/* copy the remainder of the stable part */
freeInstruction(p);
for (i = pc + 1; i < mb->stop; i++){
ns[k++] = mb->stmt[i];
}
/* remove any free instruction */
for(; i<mb->ssize; i++)
if( mb->stmt[i]){
freeInstruction(mb->stmt[i]);
mb->stmt[i]= 0;
}
GDKfree(mb->stmt);
mb->stmt = ns;
mb->ssize = l;
mb->stop = k;
GDKfree(np);
GDKfree(nv);
return pc;
}
