// Read current
INT fgd_read(EQUIPMENT * pequipment, int channel)
{
static DWORD last_time = 0;
int i, status;
FGD_INFO *fgd_info;
HNDLE hDB;
/*---- read measured value ----*/
fgd_info = (FGD_INFO *) pequipment->cd_info;
cm_get_experiment_database(&hDB, NULL);
//status = device_driver(fgd_info->driver[channel], CMD_GET_CURRENT,
// channel - fgd_info->channel_offset[channel],
// &fgd_info->measured[channel]);
///* check for update measured */
//for (i = 0; i < fgd_info->num_channels; i++) {
// /* update if change is more than update_threshold */
// if (abs(fgd_info->measured[i] - fgd_info->measured_mirror[i]) >
// fgd_info->update_threshold[i]) {
// for (i = 0; i < fgd_info->num_channels; i++)
// fgd_info->measured_mirror[i] = fgd_info->measured[i];
// db_set_data(hDB, fgd_info->hKeyMeasured, fgd_info->measured,
// sizeof(float) * fgd_info->num_channels, fgd_info->num_channels,
// TID_FLOAT);
// pequipment->odb_out++;
// break;
// }
//}
// Get the temperatures
if ((ss_time() - last_time) > 1) {
channel = 0;
status = device_driver(fgd_info->driver[channel], CMD_GET_TEMPERATURE1,
channel - fgd_info->channel_offset[channel],
&fgd_info->temp1[channel]);
db_set_data(hDB, fgd_info->hKeyTemp1, fgd_info->temp1,
sizeof(float) * fgd_info->num_channels, fgd_info->num_channels,
TID_FLOAT);
status = device_driver(fgd_info->driver[channel], CMD_GET_TEMPERATURE2,
channel - fgd_info->channel_offset[channel],
&fgd_info->temp2[channel]);
db_set_data(hDB, fgd_info->hKeyTemp2, fgd_info->temp2,
sizeof(float) * fgd_info->num_channels, fgd_info->num_channels,
TID_FLOAT);
status = device_driver(fgd_info->driver[channel], CMD_GET_TEMPERATURE3,
channel - fgd_info->channel_offset[channel],
&fgd_info->temp3[channel]);
db_set_data(hDB, fgd_info->hKeyTemp3, fgd_info->temp3,
sizeof(float) * fgd_info->num_channels, fgd_info->num_channels,
TID_FLOAT);
last_time = ss_time();
}
return status;
}
/* push index */
int qindex_push_index(QINDEX *qindex, int64_t key, IBDATA *block)
{
DOCHEADER *docheader = NULL;
XPACKET *xpackets = NULL;
int mid = 0, old = 0;
if(qindex && block->ndata > 0 && (docheader = (DOCHEADER *)block->data))
{
MUTEX_LOCK(qindex->mutex);
if(docheader->size == block->ndata && (xpackets = (XPACKET *)(qindex->xpacketio.map))
&& (mid = mmtree64_try_insert(qindex->idmap, qindex->state->rootid,
key, (qindex->state->id_max+1), &old)) > 0)
{
if(old > 0) mid = old;
else mid = ++(qindex->state->id_max);
db_set_data(PDB(qindex->db), mid, block->data, block->ndata);
if(mid <= qindex->state->xpackettotal)
{
if(xpackets[mid].crc != docheader->crc)
qindex_update(qindex, mid, 1);
else
qindex_update(qindex, mid, 0);
xpackets[mid].status = docheader->status;
xpackets[mid].crc = docheader->crc;
ACCESS_LOGGER(qindex->logger, "update-index{gloablid:%lld mid:%d total:%d}", LL(docheader->globalid), mid, qindex->state->xpackettotal);
}
else
{
qindex->state->xpackettotal = mid;
CHECK_XPACKETIO(qindex);
if((xpackets = (XPACKET *)(qindex->xpacketio.map)))
{
xpackets[mid].status = docheader->status;
xpackets[mid].crc = docheader->crc;
ACCESS_LOGGER(qindex->logger, "new-index{gloablid:%lld mid:%d}", LL(docheader->globalid), mid);
}
}
}
else
{
FATAL_LOGGER(qindex->logger, "Invalid document size:%d ndata:%d id:%lld crc:%d", docheader->size, block->ndata, LL(docheader->globalid), docheader->crc);
_exit(-1);
}
MUTEX_UNLOCK(qindex->mutex);
}
return mid;
}
/* wtable new push msg */
int wtable_new_msg(WTABLE *w, int appid, char *msg, int len, int64_t time)
{
int msgid = 0, i = 0;
char buf[W_BUF_SIZE];
WHEAD *head = (WHEAD *)buf;
if(w && appid > 0 && msg && len > 0)
{
msgid = ++(w->state->msg_id_max);
head->mix = appid;
head->len = len;
strncpy(buf + sizeof(WHEAD), msg, len);
db_set_data(w->mdb, msgid, buf, len + sizeof(WHEAD));
//gettimeofday(&tv, NULL);now = (int64_t)tv.tv_sec * 1000000 + (int64_t)tv.tv_usec;
mmtree64_try_insert(w->appmap, appid, time, msgid, NULL);
for(i = 2; i <= w->state->nworkers; i++)
{
mqueue_push(w->queue, w->workers[i].msg_qid, msgid);
}
//REALLOG(w->logger, "new-msg[%.*s] for appid:%d", len, msg, appid);
}
return msgid;
}
/*!
* <p>Set key data from a handle. Adjust number of values if previous data has different size.
*
* <p><b>Return:</b>
* - DB_SUCCESS on successful completion.
* - DB_INVALID_HANDLE if ODB or key is invalid.
* - DB_TRUNCATED if there is a size mismatch between the local structure and the ODB.
*
* \param data Pointer to the data structure.
* \param num_values Number of data elements.
* \param type Type of key, one of TID_xxx (see MIDAS documentation)
*/
INT PKey::SetData(void *data, INT num_values, DWORD type)
{
return db_set_data(fHDB, fHKey, data, num_values*fKey.item_size, num_values, type);
}
INT fgd_init(EQUIPMENT * pequipment)
{
int status, size, i, j, index, offset;
char str[256];
HNDLE hDB, hKey, hNames, hThreshold;
FGD_INFO *fgd_info;
/* allocate private data */
pequipment->cd_info = calloc(1, sizeof(FGD_INFO));
fgd_info = (FGD_INFO *) pequipment->cd_info;
/* get class driver root key */
cm_get_experiment_database(&hDB, NULL);
sprintf(str, "/Equipment/%s", pequipment->name);
db_create_key(hDB, 0, str, TID_KEY);
db_find_key(hDB, 0, str, &fgd_info->hKeyRoot);
/* save event format */
size = sizeof(str);
db_get_value(hDB, fgd_info->hKeyRoot, "Common/Format", str, &size, TID_STRING, TRUE);
if (equal_ustring(str, "Fixed"))
fgd_info->format = FORMAT_FIXED;
else if (equal_ustring(str, "MIDAS"))
fgd_info->format = FORMAT_MIDAS;
else if (equal_ustring(str, "YBOS"))
fgd_info->format = FORMAT_YBOS;
/* count total number of channels */
for (i = 0, fgd_info->num_channels = 0; pequipment->driver[i].name[0]; i++) {
if (pequipment->driver[i].channels == 0) {
cm_msg(MERROR, "fgd_init", "Driver with zero channels not allowed");
return FE_ERR_ODB;
}
fgd_info->num_channels += pequipment->driver[i].channels;
}
if (fgd_info->num_channels == 0) {
cm_msg(MERROR, "fgd_init", "No channels found in device driver list");
return FE_ERR_ODB;
}
/* Allocate memory for buffers */
fgd_info->names = (char *) calloc(fgd_info->num_channels, NAME_LENGTH);
fgd_info->demand = (float *) calloc(fgd_info->num_channels, sizeof(float));
fgd_info->measured = (float *) calloc(fgd_info->num_channels, sizeof(float));
fgd_info->temp1 = (float *) calloc(fgd_info->num_channels, sizeof(float));
fgd_info->temp2 = (float *) calloc(fgd_info->num_channels, sizeof(float));
fgd_info->temp3 = (float *) calloc(fgd_info->num_channels, sizeof(float));
fgd_info->update_threshold = (float *) calloc(fgd_info->num_channels, sizeof(float));
fgd_info->demand_mirror = (float *) calloc(fgd_info->num_channels, sizeof(float));
fgd_info->measured_mirror = (float *) calloc(fgd_info->num_channels, sizeof(float));
fgd_info->channel_offset = (INT *) calloc(fgd_info->num_channels, sizeof(INT));
fgd_info->driver = (void *) calloc(fgd_info->num_channels, sizeof(void *));
if (!fgd_info->driver) {
cm_msg(MERROR, "hv_init", "Not enough memory");
return FE_ERR_ODB;
}
/*---- Initialize device drivers ----*/
/* call init method */
for (i = 0; pequipment->driver[i].name[0]; i++) {
sprintf(str, "Settings/Devices/%s", pequipment->driver[i].name);
status = db_find_key(hDB, fgd_info->hKeyRoot, str, &hKey);
if (status != DB_SUCCESS) {
db_create_key(hDB, fgd_info->hKeyRoot, str, TID_KEY);
status = db_find_key(hDB, fgd_info->hKeyRoot, str, &hKey);
if (status != DB_SUCCESS) {
cm_msg(MERROR, "hv_init", "Cannot create %s entry in online database", str);
free_mem(fgd_info);
return FE_ERR_ODB;
}
}
status = device_driver(&pequipment->driver[i], CMD_INIT, hKey);
if (status != FE_SUCCESS) {
free_mem(fgd_info);
return status;
}
}
/* compose device driver channel assignment */
for (i = 0, j = 0, index = 0, offset = 0; i < fgd_info->num_channels; i++, j++) {
while (j >= pequipment->driver[index].channels && pequipment->driver[index].name[0]) {
offset += j;
index++;
j = 0;
}
fgd_info->driver[i] = &pequipment->driver[index];
fgd_info->channel_offset[i] = offset;
}
/*---- create demand variables ----*/
/* get demand from ODB */
status =
db_find_key(hDB, fgd_info->hKeyRoot, "Variables/Demand", &fgd_info->hKeyDemand);
if (status == DB_SUCCESS) {
size = sizeof(float) * fgd_info->num_channels;
db_get_data(hDB, fgd_info->hKeyDemand, fgd_info->demand, &size, TID_FLOAT);
}
/* let device driver overwrite demand values, if it supports it */
for (i = 0; i < fgd_info->num_channels; i++) {
if (fgd_info->driver[i]->flags & DF_PRIO_DEVICE) {
device_driver(fgd_info->driver[i], CMD_GET_DEMAND,
i - fgd_info->channel_offset[i], &fgd_info->demand[i]);
fgd_info->demand_mirror[i] = fgd_info->demand[i];
} else
fgd_info->demand_mirror[i] = -12345.f; /* use -12345 as invalid value */
}
/* write back demand values */
status =
db_find_key(hDB, fgd_info->hKeyRoot, "Variables/Demand", &fgd_info->hKeyDemand);
if (status != DB_SUCCESS) {
db_create_key(hDB, fgd_info->hKeyRoot, "Variables/Demand", TID_FLOAT);
db_find_key(hDB, fgd_info->hKeyRoot, "Variables/Demand", &fgd_info->hKeyDemand);
}
size = sizeof(float) * fgd_info->num_channels;
db_set_data(hDB, fgd_info->hKeyDemand, fgd_info->demand, size,
fgd_info->num_channels, TID_FLOAT);
db_open_record(hDB, fgd_info->hKeyDemand, fgd_info->demand,
fgd_info->num_channels * sizeof(float), MODE_READ, fgd_demand,
pequipment);
/*---- create measured variables ----*/
db_merge_data(hDB, fgd_info->hKeyRoot, "Variables/Current Measured",
fgd_info->measured, sizeof(float) * fgd_info->num_channels,
fgd_info->num_channels, TID_FLOAT);
db_find_key(hDB, fgd_info->hKeyRoot, "Variables/Current Measured", &fgd_info->hKeyMeasured);
memcpy(fgd_info->measured_mirror, fgd_info->measured,
fgd_info->num_channels * sizeof(float));
/*---- create Temp1 measured variables ----*/
db_merge_data(hDB, fgd_info->hKeyRoot, "Variables/Temp1",
fgd_info->temp1, sizeof(float) * fgd_info->num_channels,
fgd_info->num_channels, TID_FLOAT);
db_find_key(hDB, fgd_info->hKeyRoot, "Variables/Temp1", &fgd_info->hKeyTemp1);
/*---- create Temp2 measured variables ----*/
db_merge_data(hDB, fgd_info->hKeyRoot, "Variables/Temp2",
fgd_info->temp2, sizeof(float) * fgd_info->num_channels,
fgd_info->num_channels, TID_FLOAT);
db_find_key(hDB, fgd_info->hKeyRoot, "Variables/Temp2", &fgd_info->hKeyTemp2);
/*---- create Temp3 measured variables ----*/
db_merge_data(hDB, fgd_info->hKeyRoot, "Variables/Temp3",
fgd_info->temp3, sizeof(float) * fgd_info->num_channels,
fgd_info->num_channels, TID_FLOAT);
db_find_key(hDB, fgd_info->hKeyRoot, "Variables/Temp3", &fgd_info->hKeyTemp3);
/*---- get default names from device driver ----*/
for (i = 0; i < fgd_info->num_channels; i++) {
sprintf(fgd_info->names + NAME_LENGTH * i, "Default%%CH %d", i);
device_driver(fgd_info->driver[i], CMD_GET_LABEL,
i - fgd_info->channel_offset[i], fgd_info->names + NAME_LENGTH * i);
}
db_merge_data(hDB, fgd_info->hKeyRoot, "Settings/Names",
fgd_info->names, NAME_LENGTH * fgd_info->num_channels,
fgd_info->num_channels, TID_STRING);
/*---- set labels form midas SC names ----*/
for (i = 0; i < fgd_info->num_channels; i++) {
fgd_info = (FGD_INFO *) pequipment->cd_info;
device_driver(fgd_info->driver[i], CMD_SET_LABEL,
i - fgd_info->channel_offset[i], fgd_info->names + NAME_LENGTH * i);
}
/* open hotlink on channel names */
if (db_find_key(hDB, fgd_info->hKeyRoot, "Settings/Names", &hNames) == DB_SUCCESS)
db_open_record(hDB, hNames, fgd_info->names, NAME_LENGTH*fgd_info->num_channels,
MODE_READ, fgd_update_label, pequipment);
/*---- get default update threshold from device driver ----*/
for (i = 0; i < fgd_info->num_channels; i++) {
fgd_info->update_threshold[i] = 1.f; /* default 1 unit */
device_driver(fgd_info->driver[i], CMD_GET_THRESHOLD,
i - fgd_info->channel_offset[i], &fgd_info->update_threshold[i]);
}
db_merge_data(hDB, fgd_info->hKeyRoot, "Settings/Update Threshold Measured",
fgd_info->update_threshold, sizeof(float)*fgd_info->num_channels,
fgd_info->num_channels, TID_FLOAT);
/* open hotlink on update threshold */
if (db_find_key(hDB, fgd_info->hKeyRoot, "Settings/Update Threshold Measured", &hThreshold) == DB_SUCCESS)
db_open_record(hDB, hThreshold, fgd_info->update_threshold, sizeof(float)*fgd_info->num_channels,
MODE_READ, NULL, NULL);
/*---- set initial demand values ----*/
// fgd_demand(hDB, fgd_info->hKeyDemand, pequipment);
/* initially read all channels */
for (i = 0; i < fgd_info->num_channels; i++)
fgd_read(pequipment, i);
return FE_SUCCESS;
}
INT gen_read(EQUIPMENT * pequipment, int channel)
{
int i, status;
GEN_INFO *gen_info;
HNDLE hDB;
gen_info = (GEN_INFO *) pequipment->cd_info;
cm_get_experiment_database(&hDB, NULL);
/* if driver is multi-threaded, read all channels at once */
for (i=0 ; i < gen_info->num_channels ; i++) {
if (gen_info->driver[i]->flags & DF_MULTITHREAD) {
status = device_driver(gen_info->driver[i], CMD_GET,
i - gen_info->channel_offset[i],
&gen_info->measured[i]);
}
}
/* else read only single channel */
if (!(gen_info->driver[channel]->flags & DF_MULTITHREAD)) {
status = device_driver(gen_info->driver[channel], CMD_GET,
channel - gen_info->channel_offset[channel],
&gen_info->measured[channel]);
}
/* check for update measured */
for (i = 0; i < gen_info->num_channels; i++) {
/* update if change is more than update_threshold */
if ((ss_isnan(gen_info->measured[i]) && !ss_isnan(gen_info->measured_mirror[i])) ||
(!ss_isnan(gen_info->measured[i]) && ss_isnan(gen_info->measured_mirror[i])) ||
(!ss_isnan(gen_info->measured[i]) && !ss_isnan(gen_info->measured_mirror[i]) &&
abs(gen_info->measured[i] - gen_info->measured_mirror[i]) >
gen_info->update_threshold[i])) {
for (i = 0; i < gen_info->num_channels; i++)
gen_info->measured_mirror[i] = gen_info->measured[i];
db_set_data(hDB, gen_info->hKeyMeasured, gen_info->measured,
sizeof(float) * gen_info->num_channels, gen_info->num_channels,
TID_FLOAT);
pequipment->odb_out++;
break;
}
}
/*---- read demand value ----*/
status = device_driver(gen_info->driver[channel], CMD_GET_DEMAND,
channel - gen_info->channel_offset[channel],
&gen_info->demand[channel]);
if ((gen_info->demand[channel] != gen_info->demand_mirror[channel] && !ss_isnan(gen_info->demand[channel])) ||
(ss_isnan(gen_info->demand[channel]) && !ss_isnan(gen_info->demand_mirror[channel])) ||
(!ss_isnan(gen_info->demand[channel]) && ss_isnan(gen_info->demand_mirror[channel]))) {
gen_info->demand_mirror[channel] = gen_info->demand[channel];
db_set_data(hDB, gen_info->hKeyDemand, gen_info->demand,
sizeof(float) * gen_info->num_channels, gen_info->num_channels,
TID_FLOAT);
}
return status;
}
void multi_read(EQUIPMENT * pequipment, int channel)
{
int i, status;
DWORD actual_time;
MULTI_INFO *m_info;
HNDLE hDB;
m_info = (MULTI_INFO *) pequipment->cd_info;
cm_get_experiment_database(&hDB, NULL);
if (channel == -1 || m_info->driver_input[channel]->flags & DF_MULTITHREAD)
for (i = 0; i < m_info->num_channels_input; i++) {
status = device_driver(m_info->driver_input[i], CMD_GET,
i - m_info->channel_offset_input[i],
&m_info->var_input[i]);
if (status != FE_SUCCESS)
m_info->var_input[i] = (float)ss_nan();
else
m_info->var_input[i] = m_info->var_input[i] * m_info->factor_input[i] -
m_info->offset_input[i];
} else {
status = device_driver(m_info->driver_input[channel], CMD_GET,
channel - m_info->channel_offset_input[channel],
&m_info->var_input[channel]);
if (status != FE_SUCCESS)
m_info->var_input[channel] = (float)ss_nan();
else
m_info->var_input[channel] =
m_info->var_input[channel] * m_info->factor_input[channel] -
m_info->offset_input[channel];
}
/* check if significant change since last ODB update */
for (i = 0; i < m_info->num_channels_input; i++)
if ((!ss_isnan(m_info->var_input[i]) && !ss_isnan(m_info->input_mirror[i]) &&
abs(m_info->var_input[i] - m_info->input_mirror[i]) >
m_info->update_threshold[i]) ||
(ss_isnan(m_info->var_input[i]) && !ss_isnan(m_info->input_mirror[i])) ||
(!ss_isnan(m_info->var_input[i]) && ss_isnan(m_info->input_mirror[i])))
break;
#ifdef DEBUG_THRESHOLDS
if (i < m_info->num_channels_input) {
printf("%d: %lf -> %lf, threshold %lf\n", i,
m_info->var_input[i], m_info->input_mirror[i], m_info->update_threshold[i]);
}
#endif
/* update if change is more than update_sensitivity or last update more
than a minute ago */
actual_time = ss_millitime();
if (i < m_info->num_channels_input || actual_time - m_info->last_update > 60000) {
m_info->last_update = actual_time;
for (i = 0; i < m_info->num_channels_input; i++)
m_info->input_mirror[i] = m_info->var_input[i];
db_set_data(hDB, m_info->hKeyInput, m_info->var_input,
m_info->num_channels_input * sizeof(float), m_info->num_channels_input,
TID_FLOAT);
pequipment->odb_out++;
}
}
INT multi_init(EQUIPMENT * pequipment)
{
int status, size, i, j, index, ch_offset;
char str[256];
HNDLE hDB, hKey, hNamesIn, hNamesOut;
MULTI_INFO *m_info;
BOOL partially_disabled;
/* allocate private data */
pequipment->cd_info = calloc(1, sizeof(MULTI_INFO));
m_info = (MULTI_INFO *) pequipment->cd_info;
/* get class driver root key */
cm_get_experiment_database(&hDB, NULL);
sprintf(str, "/Equipment/%s", pequipment->name);
db_create_key(hDB, 0, str, TID_KEY);
db_find_key(hDB, 0, str, &m_info->hKeyRoot);
/* save event format */
size = sizeof(str);
db_get_value(hDB, m_info->hKeyRoot, "Common/Format", str, &size, TID_STRING, TRUE);
if (equal_ustring(str, "Fixed"))
m_info->format = FORMAT_FIXED;
else if (equal_ustring(str, "MIDAS"))
m_info->format = FORMAT_MIDAS;
else if (equal_ustring(str, "YBOS"))
m_info->format = FORMAT_YBOS;
/* count total number of channels */
for (i = m_info->num_channels_input = m_info->num_channels_output = 0;
pequipment->driver[i].name[0]; i++) {
if (pequipment->driver[i].flags & DF_INPUT)
m_info->num_channels_input += pequipment->driver[i].channels;
if (pequipment->driver[i].flags & DF_OUTPUT)
m_info->num_channels_output += pequipment->driver[i].channels;
}
if (m_info->num_channels_input == 0 && m_info->num_channels_output == 0) {
cm_msg(MERROR, "multi_init", "No channels found in device driver list");
return FE_ERR_ODB;
}
/* Allocate memory for buffers */
if (m_info->num_channels_input) {
m_info->names_input = (char *) calloc(m_info->num_channels_input, NAME_LENGTH);
m_info->var_input = (float *) calloc(m_info->num_channels_input, sizeof(float));
m_info->update_threshold = (float *) calloc(m_info->num_channels_input, sizeof(float));
m_info->offset_input = (float *) calloc(m_info->num_channels_input, sizeof(float));
m_info->factor_input = (float *) calloc(m_info->num_channels_input, sizeof(float));
m_info->input_mirror = (float *) calloc(m_info->num_channels_input, sizeof(float));
m_info->channel_offset_input = (INT *) calloc(m_info->num_channels_input, sizeof(INT));
m_info->driver_input = (void *) calloc(m_info->num_channels_input, sizeof(void *));
}
if (m_info->num_channels_output) {
m_info->names_output = (char *) calloc(m_info->num_channels_output, NAME_LENGTH);
m_info->var_output = (float *) calloc(m_info->num_channels_output, sizeof(float));
m_info->offset_output = (float *) calloc(m_info->num_channels_output, sizeof(float));
m_info->factor_output = (float *) calloc(m_info->num_channels_output, sizeof(float));
m_info->output_mirror = (float *) calloc(m_info->num_channels_output, sizeof(float));
m_info->channel_offset_output = (INT *) calloc(m_info->num_channels_output, sizeof(DWORD));
m_info->driver_output = (void *) calloc(m_info->num_channels_output, sizeof(void *));
}
/*---- Create/Read settings ----*/
if (m_info->num_channels_input) {
/* Update threshold */
for (i = 0; i < m_info->num_channels_input; i++)
m_info->update_threshold[i] = 0.1f; /* default 0.1 */
db_merge_data(hDB, m_info->hKeyRoot, "Settings/Update Threshold",
m_info->update_threshold, m_info->num_channels_input * sizeof(float),
m_info->num_channels_input, TID_FLOAT);
db_find_key(hDB, m_info->hKeyRoot, "Settings/Update Threshold", &hKey);
db_open_record(hDB, hKey, m_info->update_threshold,
m_info->num_channels_input * sizeof(float), MODE_READ, NULL, NULL);
/* Offset */
for (i = 0; i < m_info->num_channels_input; i++)
m_info->offset_input[i] = 0.f; /* default 0 */
db_merge_data(hDB, m_info->hKeyRoot, "Settings/Input Offset",
m_info->offset_input, m_info->num_channels_input * sizeof(float),
m_info->num_channels_input, TID_FLOAT);
db_find_key(hDB, m_info->hKeyRoot, "Settings/Input Offset", &hKey);
db_open_record(hDB, hKey, m_info->offset_input,
m_info->num_channels_input * sizeof(float), MODE_READ, NULL, NULL);
}
for (i = 0; i < m_info->num_channels_output; i++)
m_info->offset_output[i] = 0.f;
if (m_info->num_channels_output) {
db_merge_data(hDB, m_info->hKeyRoot, "Settings/Output Offset",
m_info->offset_output, m_info->num_channels_output * sizeof(float),
m_info->num_channels_output, TID_FLOAT);
db_find_key(hDB, m_info->hKeyRoot, "Settings/Output Offset", &hKey);
db_open_record(hDB, hKey, m_info->offset_output,
m_info->num_channels_output * sizeof(float), MODE_READ, NULL, NULL);
}
/* Factor */
for (i = 0; i < m_info->num_channels_input; i++)
m_info->factor_input[i] = 1.f; /* default 1 */
if (m_info->num_channels_input) {
db_merge_data(hDB, m_info->hKeyRoot, "Settings/Input Factor",
m_info->factor_input, m_info->num_channels_input * sizeof(float),
m_info->num_channels_input, TID_FLOAT);
db_find_key(hDB, m_info->hKeyRoot, "Settings/Input factor", &hKey);
db_open_record(hDB, hKey, m_info->factor_input,
m_info->num_channels_input * sizeof(float), MODE_READ, NULL, NULL);
}
if (m_info->num_channels_output) {
for (i = 0; i < m_info->num_channels_output; i++)
m_info->factor_output[i] = 1.f;
db_merge_data(hDB, m_info->hKeyRoot, "Settings/Output Factor",
m_info->factor_output, m_info->num_channels_output * sizeof(float),
m_info->num_channels_output, TID_FLOAT);
db_find_key(hDB, m_info->hKeyRoot, "Settings/Output factor", &hKey);
db_open_record(hDB, hKey, m_info->factor_output,
m_info->num_channels_output * sizeof(float), MODE_READ, NULL, NULL);
}
/*---- Create/Read variables ----*/
/* Input */
if (m_info->num_channels_input) {
db_merge_data(hDB, m_info->hKeyRoot, "Variables/Input",
m_info->var_input, m_info->num_channels_input * sizeof(float),
m_info->num_channels_input, TID_FLOAT);
db_find_key(hDB, m_info->hKeyRoot, "Variables/Input", &m_info->hKeyInput);
memcpy(m_info->input_mirror, m_info->var_input,
m_info->num_channels_input * sizeof(float));
}
/* Output */
if (m_info->num_channels_output) {
db_merge_data(hDB, m_info->hKeyRoot, "Variables/Output",
m_info->var_output, m_info->num_channels_output * sizeof(float),
m_info->num_channels_output, TID_FLOAT);
db_find_key(hDB, m_info->hKeyRoot, "Variables/Output", &m_info->hKeyOutput);
}
/*---- Initialize device drivers ----*/
/* call init method */
partially_disabled = FALSE;
for (i = 0; pequipment->driver[i].name[0]; i++) {
sprintf(str, "Settings/Devices/%s", pequipment->driver[i].name);
status = db_find_key(hDB, m_info->hKeyRoot, str, &hKey);
if (status != DB_SUCCESS) {
db_create_key(hDB, m_info->hKeyRoot, str, TID_KEY);
status = db_find_key(hDB, m_info->hKeyRoot, str, &hKey);
if (status != DB_SUCCESS) {
cm_msg(MERROR, "multi_init", "Cannot create %s entry in online database",
str);
free_mem(m_info);
return FE_ERR_ODB;
}
}
/* check enabled flag */
size = sizeof(pequipment->driver[i].enabled);
pequipment->driver[i].enabled = 1;
sprintf(str, "Settings/Devices/%s/Enabled", pequipment->driver[i].name);
status = db_get_value(hDB, m_info->hKeyRoot, str, &pequipment->driver[i].enabled, &size, TID_BOOL, TRUE);
if (status != DB_SUCCESS)
return FE_ERR_ODB;
if (pequipment->driver[i].enabled) {
status = device_driver(&pequipment->driver[i], CMD_INIT, hKey);
if (status != FE_SUCCESS) {
free_mem(m_info);
return status;
}
} else
partially_disabled = TRUE;
}
/* compose device driver channel assignment */
for (i = 0, j = 0, index = 0, ch_offset = 0; i < m_info->num_channels_input; i++, j++) {
while (pequipment->driver[index].name[0] &&
(j >= pequipment->driver[index].channels ||
(pequipment->driver[index].flags & DF_INPUT) == 0)) {
ch_offset += j;
index++;
j = 0;
}
m_info->driver_input[i] = &pequipment->driver[index];
m_info->channel_offset_input[i] = ch_offset;
}
for (i = 0, j = 0, index = 0, ch_offset = 0; i < m_info->num_channels_output; i++, j++) {
while (pequipment->driver[index].name[0] &&
(j >= pequipment->driver[index].channels ||
(pequipment->driver[index].flags & DF_OUTPUT) == 0)) {
ch_offset += j;
index++;
j = 0;
}
m_info->driver_output[i] = &pequipment->driver[index];
m_info->channel_offset_output[i] = ch_offset;
}
/*---- get default names from device driver ----*/
if (m_info->num_channels_input) {
for (i = 0; i < m_info->num_channels_input; i++) {
sprintf(m_info->names_input + NAME_LENGTH * i, "Input Channel %d", i);
device_driver(m_info->driver_input[i], CMD_GET_LABEL,
i - m_info->channel_offset_input[i],
m_info->names_input + NAME_LENGTH * i);
/* merge existing names with labels from driver */
status = db_find_key(hDB, m_info->hKeyRoot, "Settings/Names Input", &hKey);
if (status != DB_SUCCESS) {
db_create_key(hDB, m_info->hKeyRoot, "Settings/Names Input", TID_STRING);
db_find_key(hDB, m_info->hKeyRoot, "Settings/Names Input", &hKey);
db_set_data(hDB, hKey, m_info->names_input, NAME_LENGTH, 1, TID_STRING);
} else {
size = sizeof(str);
db_get_data_index(hDB, hKey, str, &size, i, TID_STRING);
if (!str[0])
db_set_data_index(hDB, hKey, m_info->names_input+NAME_LENGTH*i, NAME_LENGTH, i, TID_STRING);
}
}
}
if (m_info->num_channels_output) {
for (i = 0; i < m_info->num_channels_output; i++) {
sprintf(m_info->names_output + NAME_LENGTH * i, "Output Channel %d", i);
device_driver(m_info->driver_output[i], CMD_GET_LABEL,
i - m_info->channel_offset_output[i],
m_info->names_output + NAME_LENGTH * i);
/* merge existing names with labels from driver */
status = db_find_key(hDB, m_info->hKeyRoot, "Settings/Names Output", &hKey);
if (status != DB_SUCCESS) {
db_create_key(hDB, m_info->hKeyRoot, "Settings/Names Output", TID_STRING);
db_find_key(hDB, m_info->hKeyRoot, "Settings/Names Output", &hKey);
db_set_data(hDB, hKey, m_info->names_input, NAME_LENGTH, 1, TID_STRING);
} else {
size = sizeof(str);
db_get_data_index(hDB, hKey, str, &size, i, TID_STRING);
if (!str[0])
db_set_data_index(hDB, hKey, m_info->names_input+NAME_LENGTH*i, NAME_LENGTH, i, TID_STRING);
}
}
}
/*---- set labels from midas SC names ----*/
if (m_info->num_channels_input) {
for (i = 0; i < m_info->num_channels_input; i++) {
device_driver(m_info->driver_input[i], CMD_SET_LABEL,
i - m_info->channel_offset_input[i],
m_info->names_input + NAME_LENGTH * i);
}
/* open hotlink on input channel names */
if (db_find_key(hDB, m_info->hKeyRoot, "Settings/Names Input", &hNamesIn) ==
DB_SUCCESS)
db_open_record(hDB, hNamesIn, m_info->names_input,
NAME_LENGTH * m_info->num_channels_input, MODE_READ,
multi_update_label, pequipment);
}
for (i = 0; i < m_info->num_channels_output; i++) {
device_driver(m_info->driver_output[i], CMD_SET_LABEL,
i - m_info->channel_offset_output[i],
m_info->names_output + NAME_LENGTH * i);
}
/* open hotlink on output channel names */
if (m_info->num_channels_output) {
if (db_find_key(hDB, m_info->hKeyRoot, "Settings/Names Output", &hNamesOut) ==
DB_SUCCESS)
db_open_record(hDB, hNamesOut, m_info->names_output,
NAME_LENGTH * m_info->num_channels_output, MODE_READ,
multi_update_label, pequipment);
/* open hot link to output record */
db_open_record(hDB, m_info->hKeyOutput, m_info->var_output,
m_info->num_channels_output * sizeof(float),
MODE_READ, multi_output, pequipment);
}
/* set initial demand values */
for (i = 0; i < m_info->num_channels_output; i++) {
if (pequipment->driver[index].flags & DF_PRIO_DEVICE) {
/* read default value directly from device bypassing multi-thread buffer */
device_driver(m_info->driver_output[i], CMD_GET_DEMAND,
i - m_info->channel_offset_output[i],
&m_info->output_mirror[i]);
} else {
/* use default value from ODB */
m_info->output_mirror[i] = m_info->var_output[i] * m_info->factor_output[i] -
m_info->offset_output[i];
device_driver(m_info->driver_output[i], CMD_SET,
i - m_info->channel_offset_output[i],
m_info->output_mirror[i]);
}
}
if (m_info->num_channels_output)
db_set_record(hDB, m_info->hKeyOutput, m_info->output_mirror,
m_info->num_channels_output * sizeof(float), 0);
/* initially read all input channels */
if (m_info->num_channels_input)
multi_read(pequipment, -1);
if (partially_disabled)
return FE_PARTIALLY_DISABLED;
return FE_SUCCESS;
}
/* add document */
int ibase_add_document(IBASE *ibase, IBDATA *block)
{
int ret = -1, localid = 0, secid = 0, n = 0, newid = 0;
DOCHEADER *docheader = NULL;
MHEADER *mheader = NULL;
IHEADER *iheader = NULL;
char line[IB_LINE_MAX];
off_t size = 0;
if(ibase && block && block->ndata > 0 && (docheader = (DOCHEADER *)(block->data))
&& (secid = docheader->secid) >= 0 && secid < IB_SEC_MAX
&& ibase_check_index_state(ibase, docheader) == 0
&& docheader->globalid && (n = sprintf(line, "%lld", IBLL(docheader->globalid))))
{
if((localid = mmtrie_xadd(ibase->docmap, line, n)) > 0)
{
MUTEX_LOCK(ibase->mutex);
if(localid <= ibase->state->docid)
{
if(ibase->state->used_for == IB_USED_FOR_INDEXD)
{
if((mheader = PMHEADER(ibase, localid))
&& (iheader = PIHEADER(ibase, mheader->secid, mheader->docid)))
{
/* disabled */
if(docheader->status < 0)
{
mheader->status = -1;
iheader->status = -1;
DEBUG_LOGGER(ibase->logger, "Update docid:%d globalid:%lld status:%d", localid, IBLL(docheader->globalid), docheader->status);
ret = 0;
}
else if(docheader->crc != mheader->crc)
{
ibase_del_index(ibase, secid, localid);
newid = ++(ibase->state->ids[secid]);
DEBUG_LOGGER(ibase->logger, "ready_reindex[%lld/%d]{crc:%d rank:%f slevel:%d category:%lld}", IBLL(docheader->globalid), localid, docheader->crc, docheader->rank, docheader->slevel, LLI(docheader->category));
mheader->docid = newid;
mheader->crc = docheader->crc;
ret = ibase_index(ibase, newid, block);
DEBUG_LOGGER(ibase->logger, "over_reindex[%lld/%d]{crc:%d rank:%f slevel:%d category:%lld}", IBLL(docheader->globalid), localid, docheader->crc, docheader->rank, docheader->slevel, LLI(docheader->category));
}
else
{
DEBUG_LOGGER(ibase->logger, "update_index[%lld/%d]{crc:%d rank:%f slevel:%d category:%lld}", IBLL(docheader->globalid), localid, docheader->crc, docheader->rank, docheader->slevel, LLI(docheader->category));
ret = ibase_update_index(ibase, mheader->docid, block);
DEBUG_LOGGER(ibase->logger, "over_update_index[%lld/%d]{crc:%d rank:%f slevel:%d category:%lld}", IBLL(docheader->globalid), localid, docheader->crc, docheader->rank, docheader->slevel, LLI(docheader->category));
}
}
}
else
{
docheader->dbid = -1;
ret = ibase_index(ibase, localid, block);
}
}
else
{
if(ibase->state->used_for == IB_USED_FOR_INDEXD)
{
if(((off_t)localid * (off_t)sizeof(MHEADER)) >= ibase->mheadersio.end)
{
ibase->mheadersio.old = ibase->mheadersio.end;
size = (off_t)((localid / IB_HEADERS_BASE) + 1)
* (off_t)IB_HEADERS_BASE * (off_t)sizeof(MHEADER);
ret = ftruncate(ibase->mheadersio.fd, size);
ibase->mheadersio.end = size;
memset(ibase->mheadersio.map + ibase->mheadersio.old, 0,
ibase->mheadersio.end - ibase->mheadersio.old);
}
if((mheader = PMHEADER(ibase, localid)))
{
mheader->status = 0;
mheader->docid = ++(ibase->state->ids[secid]);
mheader->secid = docheader->secid;
mheader->crc = docheader->crc;
DEBUG_LOGGER(ibase->logger, "new_index[%lld/%d]{crc:%d rank:%f slevel:%d category:%lld}", IBLL(docheader->globalid), localid, docheader->crc, docheader->rank, docheader->slevel, LLI(docheader->category));
ret = ibase_index(ibase, mheader->docid, block);
}
}
else
{
ret = ibase_index(ibase, localid, block);
}
ibase->state->docid = localid;
}
MUTEX_UNLOCK(ibase->mutex);
if(ibase->state->used_for != IB_USED_FOR_QPARSERD
&& ibase->state->mmsource_status != IB_MMSOURCE_NULL && localid > 0)
{
ACCESS_LOGGER(ibase->logger, "docid:%lld/%d c_size:%d c_zsize:%d size:%d", docheader->globalid, localid, docheader->content_size, docheader->content_zsize, docheader->nexts_off);
docheader->size = docheader->nexts_off;
ret = db_set_data(PDB(ibase->source), localid, block->data, docheader->size);
}
ret = 0;
}
else
{
FATAL_LOGGER(ibase->logger, "new_index[%lld]{crc:%d rank:%f slevel:%d category:%lld} failed, %s", IBLL(docheader->globalid), docheader->crc, docheader->rank, docheader->slevel, LLI(docheader->category), strerror(errno));
}
}
return ret;
}
/* read upindex */
int qindex_read_upindex(QINDEX *qindex, int taskid, char *data, int *len, int *count)
{
int ret = -1, mid = -1, nodeid = -1, id = 0, k = 0, n = 0,
left = 0, prev = 0, next = 0, *px = NULL;
DOCHEADER *docheader = NULL;
XPACKET *xpackets = NULL;
QTNODE *nodes = NULL;
QTASK *tasks = NULL;
char *p = NULL;
if(qindex && taskid >= 0 && data && taskid < Q_NODE_MAX * Q_TASKS_MAX
&& len && count && *len > 0)
{
MUTEX_LOCK(qindex->mutex);
*count = 0;
k = taskid % Q_TASKS_MAX;
if((nodeid = (taskid / Q_TASKS_MAX)) < Q_NODE_MAX && (nodes = qindex->state->nodes)
&& (tasks = qindex->state->nodes[nodeid].tasks) && tasks[k].status > 0
&& (xpackets = (XPACKET *)(qindex->xpacketio.map)))
{
if(tasks[k].nupdates > 0 && tasks[k].upid != tasks[k].upover)
{
if((*len = db_read_data(PDB(qindex->update), taskid, p)) > 0)
{
*count = tasks[k].upcount;
ret = mid = tasks[k].upid;
}
else
{
tasks[k].upid = tasks[k].upover = 0;
}
}
else if(tasks[k].nqueue > 0 && tasks[k].mmqid > 0)
{
tasks[k].upcount = 0;
left = *len;
p = data;
id = mmqueue_head(MMQ(qindex->mmqueue), tasks[k].mmqid, &mid);
do
{
if(id > 0 && mid > 0)
{
if(nodes[nodeid].type == Q_NODE_INDEXD && xpackets[mid].nodeid != nodeid)
{
prev = xpackets[mid].prev;
next = xpackets[mid].next;
FATAL_LOGGER(qindex->logger, "Invalid rootid:%d id:%d prev:%d[nodeid:%d] next:%d[nodeid:%d] xpacket[%d].nodeid[%d] to task[%s:%d].nodeid:%d nqueue:%d", tasks[k].mmqid, id, prev, xpackets[prev].nodeid, next, xpackets[next].nodeid, mid, xpackets[mid].nodeid, tasks[k].ip, tasks[k].port, nodeid, tasks[k].nqueue);
tasks[k].mmqid = 0;tasks[k].nqueue = 0;
break;
}
if(db_get_data_len(PDB(qindex->db), mid) > (left-Q_LEFT_LEN)) break;
tasks[k].upid = mid;
px = (int *)p;
p += sizeof(int);
docheader = (DOCHEADER *)p;
if((n = db_read_data(PDB(qindex->db), mid, p)) > sizeof(DOCHEADER))
{
ACCESS_LOGGER(qindex->logger, "update_index(%d) globalid:%lld mid:%d status:%d nodeid:%d task[%s:%d]", id, LL(docheader->globalid), mid, xpackets[mid].status, xpackets[mid].nodeid, tasks[k].ip, tasks[k].port);
left -= n + sizeof(int);
p += n;
*px = n;
tasks[k].upcount++;
}
else
{
p -= sizeof(int);
FATAL_LOGGER(qindex->logger, "Invalid data id:%d to document:%lld", id, LL(docheader->globalid));
mid = -1;
//_exit(-1);
break;
}
mmqueue_pop(MMQ(qindex->mmqueue),tasks[k].mmqid, &mid);
tasks[k].nqueue--;
id = mmqueue_head(MMQ(qindex->mmqueue), tasks[k].mmqid, &mid);
}
else
{
FATAL_LOGGER(qindex->logger, "Invalid qid:%d mid:%d", id, mid);
tasks[k].mmqid = 0;tasks[k].nqueue = 0;
mid = -1;
break;
}
}while(tasks[k].nqueue > 0 && left > Q_LEFT_LEN && id > 0 && mid > 0);
if((*count = tasks[k].upcount) > 0 && (*len -= left) > 0
&& db_set_data(PDB(qindex->update), taskid, data, *len) >= 0)
{
ret = tasks[k].upid;
}
}
else ret = -1;
}
else ret = -2;
MUTEX_UNLOCK(qindex->mutex);
}
return ret;
}
