void rb_monitor_get_op_variables(const rb_monitor_t *monitor,
char ***vars,
size_t *vars_size) {
void *evaluator = NULL;
(*vars) = NULL;
*vars_size = 0;
struct {
char **vars;
int count;
} all_vars;
if (monitor->type != RB_MONITOR_T__OP) {
goto no_deps;
}
evaluator = evaluator_create((char *)monitor->cmd_arg);
if (NULL == evaluator) {
rdlog(LOG_ERR,
"Couldn't create an evaluator from %s",
monitor->cmd_arg);
goto no_deps;
}
evaluator_get_variables(evaluator, &all_vars.vars, &all_vars.count);
(*vars) = malloc((size_t)all_vars.count * sizeof((*vars)[0]));
if (*vars == NULL) {
rdlog(LOG_CRIT,
"Couldn't allocate memory for %d vars",
all_vars.count);
goto no_deps;
}
for (int i = 0; i < all_vars.count; ++i) {
(*vars)[i] = strdup(all_vars.vars[i]);
if (NULL == (*vars)[i]) {
rdlog(LOG_ERR,
"Couldn't strdup %s (OOM?)",
all_vars.vars[i]);
for (int j = 0; j < i; ++j) {
free((*vars)[j]);
(*vars)[j] = NULL;
}
goto no_deps;
}
}
*vars_size = (size_t)all_vars.count;
evaluator_destroy(evaluator);
return;
no_deps:
if (*vars) {
free(*vars);
}
*vars = NULL;
*vars_size = 0;
if (evaluator) {
evaluator_destroy(evaluator);
}
}
void
Polynomial::parse_parameters()
{
char** names;
int i, count;
evaluator_get_variables( m_e, &names, &count);
for( i = 0; i < count; i++)
addParameter( names[i] );
}
/* lcpi_compute */
int lcpi_compute(profile_t *profile) {
lcpi_t *hotspot_lcpi = NULL, *lcpi = NULL;
procedure_t *hotspot = NULL;
double *values = NULL;
char **names = NULL;
int count = 0;
OUTPUT_VERBOSE((4, " %s", _CYAN("Calculating LCPI metrics")));
/* For each hotspot in this profile... */
hotspot = (procedure_t *)perfexpert_list_get_first(&(profile->hotspots));
while ((perfexpert_list_item_t *)hotspot != &(profile->hotspots.sentinel)) {
OUTPUT_VERBOSE((8, " [%d] %s", hotspot->id, _YELLOW(hotspot->name)));
/* For each LCPI definition */
for (lcpi = globals.lcpi_by_name; lcpi != NULL;
lcpi = lcpi->hh_str.next) {
/* Copy LCPI definitions into this hotspot LCPI hash */
PERFEXPERT_ALLOC(lcpi_t, hotspot_lcpi, sizeof(lcpi_t));
strcpy(hotspot_lcpi->name_md5, lcpi->name_md5);
hotspot_lcpi->name = lcpi->name;
hotspot_lcpi->value = lcpi->value;
hotspot_lcpi->expression = lcpi->expression;
/* Get the list of variables and their values */
evaluator_get_variables(hotspot_lcpi->expression, &names, &count);
if (0 < count) {
int i = 0;
PERFEXPERT_ALLOC(double, values, (sizeof(double*) * count));
for (i = 0; i < count; i++) {
metric_t *metric = NULL;
char key_md5[33];
strcpy(key_md5, perfexpert_md5_string(names[i]));
perfexpert_hash_find_str(hotspot->metrics_by_name,
(char *)&key_md5, metric);
if (NULL == metric) {
perfexpert_hash_find_str(globals.machine_by_name,
(char *)&key_md5, metric);
if (NULL == metric) {
values[i] = 0.0;
} else {
values[i] = metric->value;
}
} else {
values[i] = metric->value;
}
}
/* Evaluate the LCPI expression */
hotspot_lcpi->value = evaluator_evaluate(
hotspot_lcpi->expression, count, names, values);
PERFEXPERT_DEALLOC(values);
}
/* Add the LCPI to the hotspot's list of LCPIs */
perfexpert_hash_add_str(hotspot->lcpi_by_name, name_md5,
hotspot_lcpi);
OUTPUT_VERBOSE((10, " %s=[%g]", hotspot_lcpi->name,
hotspot_lcpi->value));
}
/* Move on */
hotspot = (procedure_t *)perfexpert_list_get_next(hotspot);
}
char *oph_predicate2(UDF_INIT * initid, UDF_ARGS * args, char *result, unsigned long *length, char *is_null, char *error)
{
oph_string measure;
char *buffer;
char **names;
int count;
oph_predicate2_param *param;
int i = 0;
if (core_set_type(&(measure), args->args[0], &(args->lengths[0]))) {
pmesg(1, __FILE__, __LINE__, "Type not recognized\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
measure.content = args->args[2];
measure.length = &(args->lengths[2]);
measure.missingvalue = NULL;
core_set_elemsize(&(measure));
if (core_set_numelem(&(measure))) {
pmesg(1, __FILE__, __LINE__, "Error on counting elements\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
if (!initid->ptr) {
initid->ptr = (char *) malloc(sizeof(oph_predicate2_param));
if (!initid->ptr) {
pmesg(1, __FILE__, __LINE__, "Error allocating result string\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
param = (oph_predicate2_param *) initid->ptr;
for (i = 0; i < 4; ++i)
param->f[i] = NULL;
param->occurrence = 0; // ALL
buffer = (char *) malloc(1 + args->lengths[3]);
strncpy(buffer, args->args[3], args->lengths[3]);
buffer[args->lengths[3]] = '\0';
pthread_rwlock_wrlock(&lock);
param->f[1] = evaluator_create(buffer);
pthread_rwlock_unlock(&lock);
free(buffer);
if (!param->f[1]) {
pmesg(1, __FILE__, __LINE__, "Error allocating evaluator\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
evaluator_get_variables(param->f[1], &names, &count);
if (count > 1) {
pmesg(1, __FILE__, __LINE__, "Too variables in expression\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
// Comparison operator
if (core_set_comp(¶m->op, args->args[4], &(args->lengths[4]))) {
pmesg(1, __FILE__, __LINE__, "Comparison operator not recognized\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
if (args->args[5] && args->lengths[5]) {
buffer = (char *) malloc(1 + args->lengths[5]);
core_strncpy(buffer, args->args[5], &(args->lengths[5]));
if (!strcasecmp(buffer, "nan"))
sprintf(buffer, "0/0");
} else
buffer = strdup("0/0");
pthread_rwlock_wrlock(&lock);
param->f[2] = evaluator_create(buffer);
pthread_rwlock_unlock(&lock);
free(buffer);
if (!param->f[2]) {
pmesg(1, __FILE__, __LINE__, "Error allocating evaluator\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
evaluator_get_variables(param->f[2], &names, &count);
if (count > 1) {
pmesg(1, __FILE__, __LINE__, "Too variables in expression\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
if (args->args[6] && args->lengths[6]) {
buffer = (char *) malloc(1 + args->lengths[6]);
core_strncpy(buffer, args->args[6], &(args->lengths[6]));
if (!strcasecmp(buffer, "nan"))
sprintf(buffer, "0/0");
} else
buffer = strdup("0/0");
pthread_rwlock_wrlock(&lock);
param->f[3] = evaluator_create(buffer);
pthread_rwlock_unlock(&lock);
free(buffer);
if (!param->f[3]) {
pmesg(1, __FILE__, __LINE__, "Error allocating evaluator\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
evaluator_get_variables(param->f[3], &names, &count);
if (count > 1) {
pmesg(1, __FILE__, __LINE__, "Too variables in expression\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
oph_string output_array;
core_set_type(&output_array, args->args[1], &(args->lengths[1]));
if (!output_array.type) {
pmesg(1, __FILE__, __LINE__, "Unable to recognize measures type\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
if (core_set_elemsize(&output_array)) {
pmesg(1, __FILE__, __LINE__, "Unable to recognize measures type\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
param->result_type = output_array.type;
param->result_elemsize = output_array.elemsize;
param->length = output_array.elemsize * measure.numelem;
param->f[0] = malloc(param->length);
if (!param->f[0]) {
pmesg(1, __FILE__, __LINE__, "Error allocating result string\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
if (args->arg_count > 7) {
buffer = (char *) malloc(1 + args->lengths[7]);
core_strncpy(buffer, args->args[7], &(args->lengths[7]));
if (strcasecmp(buffer, OPH_PREDICATE2_ALL_OCCURRENCE)) {
if (!strcasecmp(buffer, OPH_PREDICATE2_FIRST_OCCURRENCE) || !strcasecmp(buffer, OPH_PREDICATE2_BEGIN_OCCURRENCE))
param->occurrence = 1;
else if (!strcasecmp(buffer, OPH_PREDICATE2_LAST_OCCURRENCE) || !strcasecmp(buffer, OPH_PREDICATE2_END_OCCURRENCE))
param->occurrence = -1;
else {
if (args->arg_type[7] == STRING_RESULT)
param->occurrence = (long) strtol(buffer, NULL, 10);
else
param->occurrence = *((long long *) args->args[7]);
if (param->occurrence < 1) {
free(buffer);
pmesg(1, __FILE__, __LINE__, "Unable to read occurrence\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
}
}
free(buffer);
}
} else
param = (oph_predicate2_param *) initid->ptr;
i = core_oph_predicate2(&measure, initid->ptr);
if (i) {
pmesg(1, __FILE__, __LINE__, "Unable to compute result\n");
*length = 0;
*is_null = 0;
*error = 1;
return NULL;
}
*length = param->length;
*error = 0;
*is_null = 0;
return (char *) param->f[0];
}
char *me_change_string(char *string, int opt, me_t * me)
{
void *f = NULL, *f_prim = NULL;
char *sep_ptr;
char *str = NULL;
char **names = NULL;
int count = 0;
char *f_prim_str = NULL;
char *vars_str = NULL;
double res = 0, res_prim = 0;
debug(NULL, "me_change_string: Entered: %s\n", string);
if (!me || !string)
return NULL;
sep_ptr = str_find_sep(string);
if (sep_ptr)
string = sep_ptr;
if (!strlen(string))
return NULL;
f = evaluator_create(string);
if (!f)
return NULL;
evaluator_get_variables(f, &names, &count);
if (!names)
goto cleanup;
vars_str =
array_to_str((void **)names, count, (char *(*)(void *))strdup);
if (!vars_str)
goto cleanup;
f_prim = evaluator_derivative_x(f);
if (!f_prim)
goto cleanup;
f_prim_str = evaluator_get_string(f_prim);
res = evaluator_evaluate_x_y_z(f, me->x, me->y, me->z);
res_prim = evaluator_evaluate_x_y_z(f_prim, me->x, me->y, me->z);
str =
str_unite("f(x,y,z)=%f ... vars={%s} ::: f'(x)=%s=%f", res,
vars_str, f_prim_str, res_prim);
cleanup:
if (f_prim)
evaluator_destroy(f_prim);
if (f)
evaluator_destroy(f);
if (vars_str)
free(vars_str);
return str;
}
void SwitchingFunction::set(const std::string & definition,std::string& errormsg){
vector<string> data=Tools::getWords(definition);
if( data.size()<1 ) errormsg="missing all input for switching function";
string name=data[0];
data.erase(data.begin());
invr0=0.0;
invr0_2=0.0;
d0=0.0;
dmax=std::numeric_limits<double>::max();
dmax_2=std::numeric_limits<double>::max();
stretch=1.0;
shift=0.0;
init=true;
bool present;
present=Tools::findKeyword(data,"D_0");
if(present && !Tools::parse(data,"D_0",d0)) errormsg="could not parse D_0";
present=Tools::findKeyword(data,"D_MAX");
if(present && !Tools::parse(data,"D_MAX",dmax)) errormsg="could not parse D_MAX";
if(dmax<std::sqrt(std::numeric_limits<double>::max())) dmax_2=dmax*dmax;
bool dostretch=false;
Tools::parseFlag(data,"STRETCH",dostretch); // this is ignored now
dostretch=true;
bool dontstretch=false;
Tools::parseFlag(data,"NOSTRETCH",dontstretch); // this is ignored now
if(dontstretch) dostretch=false;
double r0;
if(name=="CUBIC"){
r0 = dmax - d0;
} else {
bool found_r0=Tools::parse(data,"R_0",r0);
if(!found_r0) errormsg="R_0 is required";
}
invr0=1.0/r0;
invr0_2=invr0*invr0;
if(name=="RATIONAL"){
type=rational;
nn=6;
mm=0;
present=Tools::findKeyword(data,"NN");
if(present && !Tools::parse(data,"NN",nn)) errormsg="could not parse NN";
present=Tools::findKeyword(data,"MM");
if(present && !Tools::parse(data,"MM",mm)) errormsg="could not parse MM";
if(mm==0) mm=2*nn;
} else if(name=="SMAP"){
type=smap;
present=Tools::findKeyword(data,"A");
if(present && !Tools::parse(data,"A",a)) errormsg="could not parse A";
present=Tools::findKeyword(data,"B");
if(present && !Tools::parse(data,"B",b)) errormsg="could not parse B";
c=pow(2., static_cast<double>(a)/static_cast<double>(b) ) - 1;
d = -static_cast<double>(b) / static_cast<double>(a);
}
else if(name=="Q") {
type=nativeq;
beta = 50.0; // nm-1
lambda = 1.8; // unitless
present=Tools::findKeyword(data,"BETA");
if(present && !Tools::parse(data, "BETA", beta)) errormsg="could not parse BETA";
present=Tools::findKeyword(data,"LAMBDA");
if(present && !Tools::parse(data, "LAMBDA", lambda)) errormsg="could not parse LAMBDA";
bool found_ref=Tools::parse(data,"REF",ref); // nm
if(!found_ref) errormsg="REF (reference disatance) is required for native Q";
}
else if(name=="EXP") type=exponential;
else if(name=="GAUSSIAN") type=gaussian;
else if(name=="CUBIC") type=cubic;
else if(name=="TANH") type=tanh;
#ifdef __PLUMED_HAS_MATHEVAL
else if(name=="MATHEVAL"){
type=matheval;
std::string func;
Tools::parse(data,"FUNC",func);
evaluator=evaluator_create(const_cast<char*>(func.c_str()));
char **check_names;
int check_count;
evaluator_get_variables(evaluator,&check_names,&check_count);
if(check_count!=1){
errormsg="wrong number of arguments in MATHEVAL switching function";
return;
}
if(std::string(check_names[0])!="x"){
errormsg ="argument should be named 'x'";
return;
}
evaluator_deriv=evaluator_derivative(evaluator,const_cast<char*>("x"));
}
#endif
else errormsg="cannot understand switching function type '"+name+"'";
if( !data.empty() ){
errormsg="found the following rogue keywords in switching function input : ";
for(unsigned i=0;i<data.size();++i) errormsg = errormsg + data[i] + " ";
}
if(dostretch && dmax!=std::numeric_limits<double>::max()){
double dummy;
double s0=calculate(0.0,dummy);
double sd=calculate(dmax,dummy);
stretch=1.0/(s0-sd);
shift=-sd*stretch;
}
}
