END_TEST
START_TEST (test_string)
{
char *test = "test";
OmlValue v, v2;
OmlValueU vu;
size_t bcount = xmembytes();
size_t alloc_diff;
oml_value_init(&v);
oml_value_init(&v2);
omlc_zero(vu);
/* Prepare the OmlValueU to be duplicated in the OmlValue */
omlc_set_const_string(vu, test);
oml_value_set(&v, &vu, OML_STRING_VALUE);
alloc_diff = xmembytes() - bcount - sizeof(size_t);
bcount = xmembytes();
fail_if(alloc_diff < strlen(test) + 1,
"OmlValue string allocated memory not big enough (%d instead of at least %d)",
alloc_diff, strlen(test) + 1);
oml_value_duplicate(&v2, &v);
fail_if(omlc_get_string_ptr(*oml_value_get_value(&v2)) == omlc_get_string_ptr(*oml_value_get_value(&v)),
"Copied OmlValue string pointer not allocated properly");
fail_if(strcmp(omlc_get_string_ptr(*oml_value_get_value(&v2)), omlc_get_string_ptr(*oml_value_get_value(&v))),
"Copied OmlValue string mismatch ('%s' instead of '%s')",
omlc_get_string_ptr(*oml_value_get_value(&v2)), omlc_get_string_ptr(*oml_value_get_value(&v)));
fail_unless(omlc_get_string_length(*oml_value_get_value(&v2)) == strlen(omlc_get_string_ptr(*oml_value_get_value(&v2))),
"Copied OmlValue string length not set properly (%d instead of %d)",
omlc_get_string_length(*oml_value_get_value(&v2)), strlen(omlc_get_string_ptr(*oml_value_get_value(&v2))) + 1);
alloc_diff = xmembytes() - bcount - sizeof(size_t); /* oml_malloc() always allocates at least sizeof(size_t) more for bookkeeping */
bcount = xmembytes();
fail_if(alloc_diff < strlen(omlc_get_string_ptr(*oml_value_get_value(&v))) + 1,
"Copied OmlValue string allocated memory not big enough (%d instead of at least %d)",
alloc_diff, strlen(omlc_get_string_ptr(*oml_value_get_value(&v))) + 1);
fail_unless(omlc_get_string_size(*oml_value_get_value(&v2)) == oml_malloc_usable_size(omlc_get_string_ptr(*oml_value_get_value(&v2))),
"Copied OmlValue string allocated size not set properly (%d instead of %d)",
omlc_get_string_size(*oml_value_get_value(&v2)), oml_malloc_usable_size(omlc_get_string_ptr(*oml_value_get_value(&v2))));
fail_unless(omlc_get_string_is_const(*oml_value_get_value(&v2)) == 0,
"Copied OmlValue string should not be constant");
oml_value_set_type(&v, OML_UINT64_VALUE);
fail_unless(xmembytes() < bcount,
"OmlValue string was not freed after oml_value_set_type() (%d allocated, which is not less than %d)",
xmembytes(), bcount);
bcount = xmembytes();
oml_value_reset(&v2);
fail_unless(xmembytes() < bcount,
"OmlValue string was not freed after oml_value_reset() (%d allocated, which is not less than %d)",
xmembytes(), bcount);
bcount = xmembytes();
oml_value_reset(&v);
omlc_reset_string(vu);
}
int
main(int argc, const char *argv[])
{
int c, i, ret;
/* Reconstruct command line */
size_t cmdline_len = 0;
for(i = 0; i < argc; i++) {
cmdline_len += strlen(argv[i]) + 1;
}
char *cmdline = oml_malloc(cmdline_len);
cmdline[0] = '\0';
for(i = 0; i < argc; i++) {
strncat(cmdline, argv[i], cmdline_len);
cmdline_len -= strlen(argv[i]);
strncat(cmdline, " ", cmdline_len);
cmdline_len--;
}
/* Initialize OML */
if((ret = omlc_init("generator", &argc, argv, NULL)) < 0) {
logerror("Could not initialise OML\n");
return -1;
}
/* Parse command line arguments */
poptContext optCon = poptGetContext(NULL, argc, argv, options, 0); /* options is defined in generator_popt.h */
while ((c = poptGetNextOpt(optCon)) > 0) {}
/* Initialise measurement points and start OML */
oml_register_mps(); /* Defined in generator_oml.h */
if(omlc_start()) {
logerror("Could not start OML\n");
return -1;
}
/* Inject some metadata about this application */
OmlValueU v;
omlc_zero(v);
omlc_set_string(v, PACKAGE_NAME);
omlc_inject_metadata(NULL, "appname", &v, OML_STRING_VALUE, NULL);
omlc_set_string(v, PACKAGE_VERSION);
omlc_inject_metadata(NULL, "version", &v, OML_STRING_VALUE, NULL);
omlc_set_string(v, cmdline);
omlc_inject_metadata(NULL, "cmdline", &v, OML_STRING_VALUE, NULL);
omlc_reset_string(v);
oml_free(cmdline);
/* Inject measurements */
run(g_opts, g_oml_mps_generator); /* Do some work and injections, see above */
omlc_close();
return 0;
}
/** Reset one OmlValue, cleaning any allocated memory.
*
* The type of the value is also reset (to 0, i.e., OML_DOUBLE_VALUE).
*
* \param v pointer to OmlValue to reset
* \return 0 if successful, -1 otherwise
* \see oml_value_init, oml_value_array_reset, memset(3)
*/
int
oml_value_reset(OmlValue* v)
{
switch(v->type) {
case OML_LONG_VALUE:
logwarn("%s(): OML_LONG_VALUE is deprecated, please use OML_INT32_VALUE instead\n", __FUNCTION__);
case OML_INT32_VALUE:
case OML_UINT32_VALUE:
case OML_INT64_VALUE:
case OML_UINT64_VALUE:
case OML_DOUBLE_VALUE:
case OML_GUID_VALUE:
case OML_BOOL_VALUE:
/* No deep cleanup needed, memset(3) below is sufficient */
break;
case OML_STRING_VALUE:
omlc_reset_string(v->value);
break;
case OML_DATETIME_VALUE:
omlc_reset_string(v->value);
break;
case OML_BLOB_VALUE:
omlc_reset_blob(v->value);
break;
case OML_VECTOR_DOUBLE_VALUE:
case OML_VECTOR_INT32_VALUE:
case OML_VECTOR_UINT32_VALUE:
case OML_VECTOR_INT64_VALUE:
case OML_VECTOR_UINT64_VALUE:
case OML_VECTOR_BOOL_VALUE:
omlc_reset_vector(v->value);
break;
default:
logwarn("%s() for type '%d' not implemented, zeroing storage\n", __FUNCTION__, v->type);
}
memset(v, 0, sizeof(OmlValue));
return 0;
}
static void test_main(void *param)
{
int8_t result = omlc_init ("Simple");
if (result == -1) {
printf ("Could not initialise OML\n");
while(1);
} else if (result == 1) {
printf ("OML was disabled by the user, exiting\n");
while(1);
}
OmlMPDef mp_def [] = {
{ "count", OML_UINT32_VALUE },
{ "count_str", OML_STRING_VALUE },
{ "count_real", OML_DOUBLE_VALUE },
{ NULL, (OmlValueT)0 }
};
OmlMP *mp = omlc_add_mp ("counter", mp_def);
if (mp == NULL) {
printf ("Error: could not register Measurement Point 'counter'");
while(1);
}
omlc_start();
uint32_t i = 0;
for (i = 0; i < 100; i++) {
uint32_t count = i;
char count_str[16];
double count_real = (double)i;
OmlValueU values[3];
omlc_zero_array(values, 3);
snprintf(count_str, sizeof(count_str), "%d", i);
omlc_set_uint32 (values[0], count);
omlc_set_string (values[1], count_str);
omlc_set_double (values[2], count_real);
omlc_inject (mp, values);
omlc_reset_string(values[1]);
}
omlc_close();
while(1);
}
void routing_stats::inject_into_oml(unsigned mp_index){
OmlValueU v[13];
omlc_zero_array(v, 13);
omlc_set_uint32(v[0], mp_index);
omlc_set_string(v[1], node_id.c_str());
omlc_set_uint64(v[2], in_chunks);
omlc_set_uint64(v[3], out_chunks);
omlc_set_uint64(v[4], in_ctrl_msgs);
omlc_set_uint64(v[5], out_ctrl_msgs);
omlc_set_uint64(v[6], stored_chunks);
omlc_set_uint64(v[7], error_chunks);
omlc_set_uint64(v[8], dropped_chunks);
omlc_set_uint64(v[9], in_data_bytes);
omlc_set_uint64(v[10], out_data_bytes);
omlc_set_uint64(v[11], in_ctrl_bytes);
omlc_set_uint64(v[12], out_ctrl_bytes);
omlc_inject(oml_mp, v);
omlc_reset_string(v[1]);
#ifdef DEBUG
char msg[500];
sprintf(msg, "ROUTING(node: %s):\n"
"ts i-C o-C s-C e-C d-C i-dB o-dB i-cP o-cP i-cB o-cB\n"
"%llu %llu %llu %llu %llu %llu %llu %llu %llu %lld %llu %llu",
node_id.c_str(),
t_stamp,
in_chunks, out_chunks,
stored_chunks, error_chunks, dropped_chunks,
in_data_bytes, out_data_bytes,
in_ctrl_msgs, out_ctrl_msgs,
in_ctrl_bytes, out_ctrl_bytes
);
cout << "DEBUG: " << msg << endl;
#endif
}
/** Try to convert a string to the given OmlValueT and store it an OmlValueU.
*
* Storage for value should have already been cleared (e.g., with
* oml_value_set_type(), oml_value_reset() omlc_reset_string() or
* omlc_reset_blob() if appropriate).
*
* Assumes the destination OmlValueU has been properly reset.
*
* \param value pointer to output OmlValue
* \param type type of data to get from the string
* \param value_s input string
* \return 0 on success, -1 otherwise (e.g., conversion error)
* \see oml_value_from_s, oml_value_from_typed_s
* \see oml_value_set_type, oml_value_reset, omlc_reset_string, omlc_reset_blob
*/
static int
oml_value_ut_from_s (OmlValueU *value, OmlValueT type, const char *value_s)
{
char *s, *eptr;
ssize_t n;
size_t s_sz, blob_sz, nof_elts, bytes;
uint8_t *blob;
oml_guid_t c;
char *p;
char *q;
errno = 0; /* Not all paths manipulate errno, so make sure its value is reset */
switch (type) {
case OML_LONG_VALUE:
logwarn("%s(): OML_LONG_VALUE is deprecated, please use OML_INT32_VALUE instead\n", __FUNCTION__);
omlc_set_long (*value, strtol (value_s, NULL, 0));
break;
case OML_INT32_VALUE:
omlc_set_int32 (*value, strtol (value_s, NULL, 0));
break;
case OML_UINT32_VALUE:
omlc_set_uint32 (*value, strtoul (value_s, NULL, 0));
break;
case OML_INT64_VALUE:
omlc_set_int64 (*value, strtoll (value_s, NULL, 0));
break;
case OML_UINT64_VALUE:
omlc_set_uint64 (*value, strtoull (value_s, NULL, 0));
break;
case OML_DOUBLE_VALUE: {
omlc_set_double (*value, strtod (value_s, &eptr));
if (eptr == value_s) {
omlc_set_double (*value, NAN);
}
break;
}
case OML_STRING_VALUE:
s = oml_malloc(strlen(value_s)+1);
n = backslash_decode(value_s, s);
omlc_reset_string(*value);
omlc_set_string(*value, s);
omlc_set_string_size(*value,n+1);
break;
case OML_DATETIME_VALUE:
s = oml_malloc(strlen(value_s)+1);
n = backslash_decode(value_s, s);
omlc_reset_string(*value);
omlc_set_string(*value, s);
omlc_set_string_size(*value,n+1);
break;
case OML_BLOB_VALUE:
omlc_reset_blob(*value);
s_sz = base64_validate_string(value_s);
if(s_sz != -1) {
blob_sz = base64_size_blob(s_sz);
blob = oml_malloc(blob_sz);
base64_decode_string(s_sz, value_s, blob_sz, blob);
omlc_set_blob_ptr(*value, blob);
omlc_set_blob_length(*value, blob_sz);
omlc_set_blob_size(*value, blob_sz);
}
break;
case OML_GUID_VALUE:
omlc_string_to_guid(value_s, &c);
omlc_set_guid(*value, c);
break;
case OML_BOOL_VALUE:
omlc_set_bool(*value, oml_value_string_to_bool(value_s));
break;
case OML_VECTOR_DOUBLE_VALUE:
omlc_reset_vector(*value);
nof_elts = strtod(value_s, &p);
if(p - value_s) {
size_t i, bytes;
double *elts = oml_calloc(nof_elts, sizeof(double));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtod(p, &q);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [double] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(double);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(double));
} else {
logerror("%s(): out of memory reading [double] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [double] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_INT32_VALUE:
omlc_reset_vector(*value);
nof_elts = strtol(value_s, &p, 0);
if(p - value_s) {
size_t i;
int32_t *elts = oml_calloc(nof_elts, sizeof(int32_t));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtol(p, &q, 0);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [int32] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(int32_t);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(int32_t));
} else {
logerror("%s(): out of memory reading [int32] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [int32] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_UINT32_VALUE:
omlc_reset_vector(*value);
nof_elts = strtoul(value_s, &p, 0);
if(p - value_s) {
size_t i;
uint32_t *elts = oml_calloc(nof_elts, sizeof(uint32_t));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtoul(p, &q, 0);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [uint32] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(uint32_t);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(uint32_t));
} else {
logerror("%s(): out of memory reading [uint32] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [uint32] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_INT64_VALUE:
omlc_reset_vector(*value);
nof_elts = strtoll(value_s, &p, 0);
if(p - value_s) {
size_t i;
int64_t *elts = oml_calloc(nof_elts, sizeof(int64_t));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtoll(p, &q, 0);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [int64] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(int64_t);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(int64_t));
} else {
logerror("%s(): out of memory reading [int64] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [int64] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_UINT64_VALUE:
omlc_reset_vector(*value);
nof_elts = strtoull(value_s, &p, 0);
if(p - value_s) {
size_t i;
uint64_t *elts = oml_calloc(nof_elts, sizeof(uint64_t));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtoull(p, &q, 0);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [uint64] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(uint64_t);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(uint64_t));
} else {
logerror("%s(): out of memory reading [uint64] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [uint64] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_BOOL_VALUE:
omlc_reset_vector(*value);
nof_elts = strtoul(value_s, &p, 0);
if(p - value_s) {
char *n;
size_t i;
bool *elts = oml_calloc(nof_elts, sizeof(bool));
if(elts) {
for(i = 0; i < nof_elts; i++) {
char *v = strtok_r(p, " ", &n);
if(v) {
elts[i] = strncasecmp(v, "false", strlen(v));
p = n;
} else {
oml_free(elts);
logerror("%s(): bad [bool] '%s'\n", __FUNCTION__, p);
return -1;
}
}
omlc_set_vector_bool(*value, elts, nof_elts);
bytes = nof_elts * sizeof(bool);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(bool));
} else {
logerror("%s(): out of memory reading [bool] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [bool] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
default:
logerror("%s() for type '%d' not implemented to convert '%s'\n", __FUNCTION__, type, value_s);
return -1;
}
if (errno == ERANGE) {
logerror("%s(): underflow or overlow converting value from string '%s'\n", __FUNCTION__, value_s);
return -1;
}
return 0;
}
