static int extract_raw_pdescs (flux_t *h, int64_t j, int64_t n, json_object *jcb)
{
int rc = -1;
int64_t i = 0;
char *hnm;
const char *cmd = NULL;
zhash_t *eh = NULL; /* hash holding a set of unique exec_names */
zhash_t *hh = NULL; /* hash holding a set of unique host_names */
json_object *o = NULL;
json_object *po = NULL;
json_object *pa = Jnew_ar ();
json_object *hns = Jnew_ar ();
json_object *ens = Jnew_ar ();
if (!(eh = zhash_new ()) || !(hh = zhash_new ()))
oom ();
for (i=0; i < (int) n; i++) {
int64_t eix = 0, hix = 0;
int64_t pid = 0, nid = 0;
if (extract_raw_pdesc (h, j, i, &o) != 0)
goto done;
if (!fetch_rank_pdesc (o, &pid, &nid, &cmd))
goto done;
eix = build_name_array (eh, cmd, ens);
/* FIXME: we need a hostname service */
hnm = xasprintf ("%"PRId64, nid);
hix = build_name_array (hh, hnm, hns);
po = build_parray_elem (pid, eix, hix);
json_object_array_add (pa, po);
po = NULL;
Jput (o);
o = NULL;
free (hnm);
}
add_pdescs_to_jcb (&hns, &ens, &pa, jcb);
rc = 0;
done:
if (o) Jput (o);
if (po) Jput (po);
if (pa) Jput (pa);
if (hns) Jput (hns);
if (ens) Jput (ens);
zhash_destroy (&eh);
zhash_destroy (&hh);
return rc;
}
static int extract_raw_rdl_alloc (flux_t *h, int64_t j, json_object *jcb)
{
int i;
json_object *ra = Jnew_ar ();
bool processing = true;
for (i=0; processing; ++i) {
char *key = lwj_key (h, j, ".rank.%d.cores", i);
flux_future_t *f = NULL;
int64_t cores = 0;
if (!key || !(f = flux_kvs_lookup (h, 0, key))
|| flux_kvs_lookup_get_unpack (f, "I", &cores) < 0) {
if (errno != EINVAL)
flux_log_error (h, "extract %s", key);
processing = false;
} else {
json_object *elem = Jnew ();
json_object *o = Jnew ();
Jadd_int64 (o, JSC_RDL_ALLOC_CONTAINED_NCORES, cores);
json_object_object_add (elem, JSC_RDL_ALLOC_CONTAINED, o);
json_object_array_add (ra, elem);
}
free (key);
flux_future_destroy (f);
}
json_object_object_add (jcb, JSC_RDL_ALLOC, ra);
return 0;
}
static int extract_raw_rdl_alloc (flux_t h, int64_t j, JSON jcb)
{
int i = 0;
char k[20];
int64_t cores = 0;
JSON ra = Jnew_ar ();
bool processing = true;
for (i=0; processing; ++i) {
snprintf (k, 20, "lwj.%ld.rank.%d.cores", j, i);
if (kvs_get_int64 (h, k, &cores) < 0) {
if (errno != EINVAL)
flux_log (h, LOG_ERR, "extract %s: %s", k, strerror (errno));
processing = false;
} else {
JSON elem = Jnew ();
JSON o = Jnew ();
Jadd_int64 (o, JSC_RDL_ALLOC_CONTAINED_NCORES, cores);
json_object_object_add (elem, JSC_RDL_ALLOC_CONTAINED, o);
json_object_array_add (ra, elem);
}
}
json_object_object_add (jcb, JSC_RDL_ALLOC, ra);
return 0;
}
static int extract_raw_rdl_alloc (flux_t h, int64_t j, JSON jcb)
{
int i = 0;
char *key;
int64_t cores = 0;
JSON ra = Jnew_ar ();
bool processing = true;
for (i=0; processing; ++i) {
key = xasprintf ("lwj.%"PRId64".rank.%"PRId32".cores", j, i);
if (kvs_get_int64 (h, key, &cores) < 0) {
if (errno != EINVAL)
flux_log_error (h, "extract %s", key);
processing = false;
} else {
JSON elem = Jnew ();
JSON o = Jnew ();
Jadd_int64 (o, JSC_RDL_ALLOC_CONTAINED_NCORES, cores);
json_object_object_add (elem, JSC_RDL_ALLOC_CONTAINED, o);
json_object_array_add (ra, elem);
}
free (key);
}
json_object_object_add (jcb, JSC_RDL_ALLOC, ra);
return 0;
}
int resrc_flow_serialize (json_t *o, resrc_flow_t *resrc_flow)
{
int rc = -1;
if (o && resrc_flow) {
rc = resrc_to_json (o, resrc_flow->flow_resrc);
if (!rc && resrc_flow_num_children (resrc_flow)) {
json_t *ja = Jnew_ar ();
if (!(rc = resrc_flow_list_serialize (ja, resrc_flow->children)))
json_object_set_new (o, "children", ja);
}
}
return rc;
}
static int test_a_resrc (resrc_t *resrc, bool rdl)
{
int found = 0;
int rc = 0;
int64_t nowtime = epochtime ();
JSON o = NULL;
JSON req_res = NULL;
resrc_reqst_t *resrc_reqst = NULL;
resrc_tree_t *deserialized_tree = NULL;
resrc_tree_t *found_tree = NULL;
resrc_tree_t *resrc_tree = NULL;
resrc_tree_t *selected_tree = NULL;
resrc_tree = resrc_phys_tree (resrc);
ok ((resrc_tree != NULL), "resource tree valid");
if (!resrc_tree)
goto ret;
if (verbose) {
printf ("Listing resource tree\n");
resrc_tree_print (resrc_tree);
printf ("End of resource tree\n");
}
/*
* Build a resource composite to search for. Two variants are
* constructed depending on whether the loaded resources came
* from the sample RDL file or from the hwloc. The hwloc request
* does not span multiple nodes or contain the localid property.
*/
req_res = Jnew ();
if (rdl) {
JSON bandwidth = Jnew ();
JSON child_core = Jnew ();
JSON child_sock = Jnew ();
JSON graph_array = Jnew_ar ();
JSON ja = Jnew_ar ();
JSON jpropo = Jnew (); /* json property object */
JSON memory = Jnew ();
JSON power = Jnew ();
/* JSON jtago = Jnew (); /\* json tag object *\/ */
/* Jadd_bool (jtago, "maytag", true); */
/* Jadd_bool (jtago, "yourtag", true); */
Jadd_str (memory, "type", "memory");
Jadd_int (memory, "req_qty", 1);
Jadd_int (memory, "size", 100);
json_object_array_add (ja, memory);
Jadd_str (child_core, "type", "core");
Jadd_int (child_core, "req_qty", 6);
Jadd_bool (child_core, "exclusive", true);
Jadd_int (jpropo, "localid", 1);
json_object_object_add (child_core, "properties", jpropo);
json_object_array_add (ja, child_core);
Jadd_str (child_sock, "type", "socket");
Jadd_int (child_sock, "req_qty", 2);
json_object_object_add (child_sock, "req_children", ja);
Jadd_str (bandwidth, "type", "bandwidth");
Jadd_int (bandwidth, "size", 100);
json_object_array_add (graph_array, bandwidth);
Jadd_str (power, "type", "power");
Jadd_int (power, "size", 10);
json_object_array_add (graph_array, power);
Jadd_str (req_res, "type", "node");
Jadd_int (req_res, "req_qty", 2);
Jadd_int64 (req_res, "starttime", nowtime);
/* json_object_object_add (req_res, "tags", jtago); */
json_object_object_add (req_res, "req_child", child_sock);
json_object_object_add (req_res, "graphs", graph_array);
} else {
Jadd_str (req_res, "type", "core");
Jadd_int (req_res, "req_qty", 2);
Jadd_bool (req_res, "exclusive", true);
}
resrc_reqst = resrc_reqst_from_json (req_res, NULL);
Jput (req_res);
ok ((resrc_reqst != NULL), "resource request valid");
if (!resrc_reqst)
goto ret;
if (verbose) {
printf ("Listing resource request tree\n");
resrc_reqst_print (resrc_reqst);
printf ("End of resource request tree\n");
}
init_time ();
found = resrc_tree_search (resrc, resrc_reqst, &found_tree, true);
ok (found, "found %d requested resources in %lf", found,
((double)get_time ())/1000000);
if (!found)
goto ret;
if (verbose) {
printf ("Listing found tree\n");
resrc_tree_print (found_tree);
printf ("End of found tree\n");
}
o = Jnew ();
init_time ();
rc = resrc_tree_serialize (o, found_tree);
ok (!rc, "found resource serialization took: %lf",
((double)get_time ())/1000000);
if (verbose) {
printf ("The found resources serialized: %s\n", Jtostr (o));
}
deserialized_tree = resrc_tree_deserialize (o, NULL);
if (verbose) {
printf ("Listing deserialized tree\n");
resrc_tree_print (deserialized_tree);
printf ("End of deserialized tree\n");
}
Jput (o);
init_time ();
/*
* Exercise time-based allocations for the rdl case and
* now-based allocations for the hwloc case
*/
selected_tree = test_select_resources (found_tree, NULL, 1);
if (rdl)
rc = resrc_tree_allocate (selected_tree, 1, nowtime, nowtime + 3600);
else
rc = resrc_tree_allocate (selected_tree, 1, 0, 0);
ok (!rc, "successfully allocated resources for job 1");
resrc_tree_destroy (selected_tree, false);
resrc_tree_unstage_resources (found_tree);
selected_tree = test_select_resources (found_tree, NULL, 2);
if (rdl)
rc = resrc_tree_allocate (selected_tree, 2, nowtime, nowtime + 3600);
else
rc = resrc_tree_allocate (selected_tree, 2, 0, 0);
ok (!rc, "successfully allocated resources for job 2");
resrc_tree_destroy (selected_tree, false);
resrc_tree_unstage_resources (found_tree);
selected_tree = test_select_resources (found_tree, NULL, 3);
if (rdl)
rc = resrc_tree_allocate (selected_tree, 3, nowtime, nowtime + 3600);
else
rc = resrc_tree_allocate (selected_tree, 3, 0, 0);
ok (!rc, "successfully allocated resources for job 3");
resrc_tree_destroy (selected_tree, false);
resrc_tree_unstage_resources (found_tree);
selected_tree = test_select_resources (found_tree, NULL, 4);
if (rdl)
rc = resrc_tree_reserve (selected_tree, 4, nowtime, nowtime + 3600);
else
rc = resrc_tree_reserve (selected_tree, 4, 0, 0);
ok (!rc, "successfully reserved resources for job 4");
resrc_tree_destroy (selected_tree, false);
resrc_tree_unstage_resources (found_tree);
printf (" allocate and reserve took: %lf\n",
((double)get_time ())/1000000);
if (verbose) {
printf ("Allocated and reserved resources\n");
resrc_tree_print (resrc_tree);
}
init_time ();
rc = resrc_tree_release (found_tree, 1);
ok (!rc, "resource release of job 1 took: %lf",
((double)get_time ())/1000000);
if (verbose) {
printf ("Same resources without job 1\n");
resrc_tree_print (resrc_tree);
}
init_time ();
resrc_reqst_destroy (resrc_reqst);
resrc_tree_destroy (deserialized_tree, true);
resrc_tree_destroy (found_tree, false);
printf (" destroy took: %lf\n", ((double)get_time ())/1000000);
ret:
return rc;
}
