static size_t
hwloc___nolibxml_prepare_export_diff(hwloc_topology_diff_t diff, const char *refname, char *xmlbuffer, int buflen)
{
struct hwloc__xml_export_state_s state, childstate;
hwloc__nolibxml_export_state_data_t ndata = (void *) &state.data;
int res;
HWLOC_BUILD_ASSERT(sizeof(*ndata) <= sizeof(state.data));
state.new_child = hwloc__nolibxml_export_new_child;
state.new_prop = hwloc__nolibxml_export_new_prop;
state.add_content = hwloc__nolibxml_export_add_content;
state.end_object = hwloc__nolibxml_export_end_object;
state.global = NULL;
ndata->indent = 0;
ndata->written = 0;
ndata->buffer = xmlbuffer;
ndata->remaining = buflen;
ndata->nr_children = 1; /* don't close a non-existing previous tag when opening the topology tag */
ndata->has_content = 0;
res = hwloc_snprintf(ndata->buffer, ndata->remaining,
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<!DOCTYPE topologydiff SYSTEM \"hwloc2-diff.dtd\">\n");
hwloc__nolibxml_export_update_buffer(ndata, res);
hwloc__nolibxml_export_new_child(&state, &childstate, "topologydiff");
if (refname)
hwloc__nolibxml_export_new_prop(&childstate, "refname", refname);
hwloc__xml_export_diff (&childstate, diff);
hwloc__nolibxml_export_end_object(&childstate, "topologydiff");
return ndata->written+1;
}
static int
hwloc_nolibxml_look_init(struct hwloc_xml_backend_data_s *bdata,
struct hwloc__xml_import_state_s *state)
{
hwloc__nolibxml_import_state_data_t nstate = (void*) state->data;
struct hwloc__nolibxml_backend_data_s *nbdata = bdata->data;
unsigned major, minor;
char *end;
char *buffer = nbdata->buffer;
char *tagname;
HWLOC_BUILD_ASSERT(sizeof(*nstate) <= sizeof(state->data));
/* skip headers */
while (!strncmp(buffer, "<?xml ", 6) || !strncmp(buffer, "<!DOCTYPE ", 10)) {
buffer = strchr(buffer, '\n');
if (!buffer)
goto failed;
buffer++;
}
/* find topology tag */
if (sscanf(buffer, "<topology version=\"%u.%u\">", &major, &minor) == 2) {
bdata->version_major = major;
bdata->version_minor = minor;
end = strchr(buffer, '>') + 1;
tagname = "topology";
} else if (!strncmp(buffer, "<topology>", 10)) {
bdata->version_major = 1;
bdata->version_minor = 0;
end = buffer + 10;
tagname = "topology";
} else if (!strncmp(buffer, "<root>", 6)) {
bdata->version_major = 0;
bdata->version_minor = 9;
end = buffer + 6;
tagname = "root";
} else
goto failed;
state->global->next_attr = hwloc__nolibxml_import_next_attr;
state->global->find_child = hwloc__nolibxml_import_find_child;
state->global->close_tag = hwloc__nolibxml_import_close_tag;
state->global->close_child = hwloc__nolibxml_import_close_child;
state->global->get_content = hwloc__nolibxml_import_get_content;
state->global->close_content = hwloc__nolibxml_import_close_content;
state->parent = NULL;
nstate->closed = 0;
nstate->tagbuffer = end;
nstate->tagname = tagname;
nstate->attrbuffer = NULL;
return 0; /* success */
failed:
return -1; /* failed */
}
static int
hwloc_nolibxml_look_init(struct hwloc_xml_backend_data_s *bdata,
struct hwloc__xml_import_state_s *state)
{
hwloc__nolibxml_import_state_data_t nstate = (void*) state->data;
struct hwloc__nolibxml_backend_data_s *nbdata = bdata->data;
char *buffer;
HWLOC_BUILD_ASSERT(sizeof(*nstate) <= sizeof(state->data));
/* use a copy in the temporary buffer, we may modify during parsing */
buffer = nbdata->copy;
memcpy(buffer, nbdata->buffer, nbdata->buflen);
/* skip headers */
while (!strncmp(buffer, "<?xml ", 6) || !strncmp(buffer, "<!DOCTYPE ", 10)) {
buffer = strchr(buffer, '\n');
if (!buffer)
goto failed;
buffer++;
}
/* find topology tag */
if (strncmp(buffer, "<topology>", 10)) {
if (hwloc__xml_verbose()) {
if (!strncmp(buffer, "<topology version=", 18))
fprintf(stderr, "%s: hwloc v1.x cannot import topology version >= 2.\n",
state->global->msgprefix);
else
fprintf(stderr, "%s: failed to find starting tag <topology>\n",
state->global->msgprefix);
}
goto failed;
}
state->global->next_attr = hwloc__nolibxml_import_next_attr;
state->global->find_child = hwloc__nolibxml_import_find_child;
state->global->close_tag = hwloc__nolibxml_import_close_tag;
state->global->close_child = hwloc__nolibxml_import_close_child;
state->global->get_content = hwloc__nolibxml_import_get_content;
state->global->close_content = hwloc__nolibxml_import_close_content;
state->parent = NULL;
nstate->closed = 0;
nstate->tagbuffer = buffer+10;
nstate->tagname = (char *) "topology";
nstate->attrbuffer = NULL;
return 0; /* success */
failed:
return -1; /* failed */
}
/* called at the beginning of load() */
void hwloc_internal_distances_prepare(struct hwloc_topology *topology)
{
char *env;
hwloc_localeswitch_declare;
topology->grouping = 1;
if (topology->type_filter[HWLOC_OBJ_GROUP] == HWLOC_TYPE_FILTER_KEEP_NONE)
topology->grouping = 0;
env = getenv("HWLOC_GROUPING");
if (env && !atoi(env))
topology->grouping = 0;
if (topology->grouping) {
topology->grouping_next_subkind = 0;
HWLOC_BUILD_ASSERT(sizeof(topology->grouping_accuracies)/sizeof(*topology->grouping_accuracies) == 5);
topology->grouping_accuracies[0] = 0.0f;
topology->grouping_accuracies[1] = 0.01f;
topology->grouping_accuracies[2] = 0.02f;
topology->grouping_accuracies[3] = 0.05f;
topology->grouping_accuracies[4] = 0.1f;
topology->grouping_nbaccuracies = 5;
hwloc_localeswitch_init();
env = getenv("HWLOC_GROUPING_ACCURACY");
if (!env) {
/* only use 0.0 */
topology->grouping_nbaccuracies = 1;
} else if (strcmp(env, "try")) {
/* use the given value */
topology->grouping_nbaccuracies = 1;
topology->grouping_accuracies[0] = (float) atof(env);
} /* otherwise try all values */
hwloc_localeswitch_fini();
topology->grouping_verbose = 0;
env = getenv("HWLOC_GROUPING_VERBOSE");
if (env)
topology->grouping_verbose = atoi(env);
}
}
static size_t
hwloc___nolibxml_prepare_export(hwloc_topology_t topology, struct hwloc__xml_export_data_s *edata,
char *xmlbuffer, int buflen, unsigned long flags)
{
struct hwloc__xml_export_state_s state, childstate;
hwloc__nolibxml_export_state_data_t ndata = (void *) &state.data;
int v1export = flags & HWLOC_TOPOLOGY_EXPORT_XML_FLAG_V1;
int res;
HWLOC_BUILD_ASSERT(sizeof(*ndata) <= sizeof(state.data));
state.new_child = hwloc__nolibxml_export_new_child;
state.new_prop = hwloc__nolibxml_export_new_prop;
state.add_content = hwloc__nolibxml_export_add_content;
state.end_object = hwloc__nolibxml_export_end_object;
state.global = edata;
ndata->indent = 0;
ndata->written = 0;
ndata->buffer = xmlbuffer;
ndata->remaining = buflen;
ndata->nr_children = 1; /* don't close a non-existing previous tag when opening the topology tag */
ndata->has_content = 0;
res = hwloc_snprintf(ndata->buffer, ndata->remaining,
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<!DOCTYPE topology SYSTEM \"%s\">\n", v1export ? "hwloc.dtd" : "hwloc2.dtd");
hwloc__nolibxml_export_update_buffer(ndata, res);
hwloc__nolibxml_export_new_child(&state, &childstate, "topology");
if (!(flags & HWLOC_TOPOLOGY_EXPORT_XML_FLAG_V1))
hwloc__nolibxml_export_new_prop(&childstate, "version", "2.0");
hwloc__xml_export_topology (&childstate, topology, flags);
hwloc__nolibxml_export_end_object(&childstate, "topology");
return ndata->written+1; /* ending \0 */
}
static int
hwloc_nolibxml_import_diff(struct hwloc__xml_import_state_s *state,
const char *xmlpath, const char *xmlbuffer, int xmlbuflen,
hwloc_topology_diff_t *firstdiffp, char **refnamep)
{
hwloc__nolibxml_import_state_data_t nstate = (void*) state->data;
struct hwloc__xml_import_state_s childstate;
char *refname = NULL;
char *buffer, *tmp, *tag;
size_t buflen;
int ret;
HWLOC_BUILD_ASSERT(sizeof(*nstate) <= sizeof(state->data));
if (xmlbuffer) {
buffer = malloc(xmlbuflen);
if (!buffer)
goto out;
memcpy(buffer, xmlbuffer, xmlbuflen);
buflen = xmlbuflen;
} else {
ret = hwloc_nolibxml_read_file(xmlpath, &buffer, &buflen);
if (ret < 0)
goto out;
}
/* skip headers */
tmp = buffer;
while (!strncmp(tmp, "<?xml ", 6) || !strncmp(tmp, "<!DOCTYPE ", 10)) {
tmp = strchr(tmp, '\n');
if (!tmp)
goto out_with_buffer;
tmp++;
}
state->global->next_attr = hwloc__nolibxml_import_next_attr;
state->global->find_child = hwloc__nolibxml_import_find_child;
state->global->close_tag = hwloc__nolibxml_import_close_tag;
state->global->close_child = hwloc__nolibxml_import_close_child;
state->global->get_content = hwloc__nolibxml_import_get_content;
state->global->close_content = hwloc__nolibxml_import_close_content;
state->parent = NULL;
nstate->closed = 0;
nstate->tagbuffer = tmp;
nstate->tagname = NULL;
nstate->attrbuffer = NULL;
/* find root */
ret = hwloc__nolibxml_import_find_child(state, &childstate, &tag);
if (ret < 0)
goto out_with_buffer;
if (!tag || strcmp(tag, "topologydiff"))
goto out_with_buffer;
while (1) {
char *attrname, *attrvalue;
if (hwloc__nolibxml_import_next_attr(&childstate, &attrname, &attrvalue) < 0)
break;
if (!strcmp(attrname, "refname")) {
free(refname);
refname = strdup(attrvalue);
} else
goto out_with_buffer;
}
ret = hwloc__xml_import_diff(&childstate, firstdiffp);
if (refnamep && !ret)
*refnamep = refname;
else
free(refname);
free(buffer);
return ret;
out_with_buffer:
free(buffer);
free(refname);
out:
return -1;
}
/*****************************************************************************
Assigns values based on the value of index. For this reason, the order of
the items array is important.
*****************************************************************************/
static void assign_value(int index, long long val) {
if (index == INDEX_IMPLEMENTATION) {
/* implementation# T1, T2, and Rock do not have this, see RFE 6615268 */
long dss_chip_impl = val;
if (dss_chip_impl == IMPL_SPITFIRE) {
dss_chip_mode = MODE_SPITFIRE;
}
else if ((dss_chip_impl >= IMPL_BLACKBIRD) &&
(dss_chip_impl <= IMPL_HUMMINGBIRD)) {
dss_chip_mode = MODE_BLACKBIRD;
}
else if ((dss_chip_impl >= IMPL_CHEETAH) &&
(dss_chip_impl <= IMPL_PANTHER)) {
dss_chip_mode = MODE_CHEETAH;
}
else if (dss_chip_impl == IMPL_SPARC64_VI) {
dss_chip_mode = MODE_SPARC64_VI;
}
else if (dss_chip_impl == IMPL_NIAGARA) {
dss_chip_mode = MODE_T1;
}
else if (dss_chip_impl == IMPL_NIAGARA_2) {
dss_chip_mode = MODE_T2;
}
else if (dss_chip_impl == IMPL_SPARC64_VII) {
dss_chip_mode = MODE_SPARC64_VII;
}
else if (dss_chip_impl == IMPL_ROCK) {
dss_chip_mode = MODE_ROCK;
}
}
else if ((index >= INDEX_L1I_CACHE_SIZE) && (index <= INDEX_L3_CACHE_SIZE)) {
/* make sure our indexes and the target structure are ordered the same */
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_SIZE+HWLOC_SOLARIS_CHIP_INFO_L1I == INDEX_L1I_CACHE_SIZE);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_SIZE+HWLOC_SOLARIS_CHIP_INFO_L1D == INDEX_L1D_CACHE_SIZE);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_SIZE+HWLOC_SOLARIS_CHIP_INFO_L2I == INDEX_L2I_CACHE_SIZE);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_SIZE+HWLOC_SOLARIS_CHIP_INFO_L2D == INDEX_L2D_CACHE_SIZE);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_SIZE+HWLOC_SOLARIS_CHIP_INFO_L3 == INDEX_L3_CACHE_SIZE);
chip_info.cache_size[index-INDEX_L1I_CACHE_SIZE] = val;
}
else if ((index >= INDEX_L1I_CACHE_LINESIZE) && (index <= INDEX_L3_CACHE_LINESIZE)) {
/* make sure our indexes and the target structure are ordered the same */
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_LINESIZE+HWLOC_SOLARIS_CHIP_INFO_L1I == INDEX_L1I_CACHE_LINESIZE);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_LINESIZE+HWLOC_SOLARIS_CHIP_INFO_L1D == INDEX_L1D_CACHE_LINESIZE);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_LINESIZE+HWLOC_SOLARIS_CHIP_INFO_L2I == INDEX_L2I_CACHE_LINESIZE);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_LINESIZE+HWLOC_SOLARIS_CHIP_INFO_L2D == INDEX_L2D_CACHE_LINESIZE);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_LINESIZE+HWLOC_SOLARIS_CHIP_INFO_L3 == INDEX_L3_CACHE_LINESIZE);
chip_info.cache_linesize[index-INDEX_L1I_CACHE_LINESIZE] = val;
}
else if ((index >= INDEX_L1I_CACHE_ASSOCIATIVITY) && (index <= INDEX_L3_CACHE_ASSOCIATIVITY)) {
/* make sure our indexes and the target structure are ordered the same */
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_ASSOCIATIVITY+HWLOC_SOLARIS_CHIP_INFO_L1I == INDEX_L1I_CACHE_ASSOCIATIVITY);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_ASSOCIATIVITY+HWLOC_SOLARIS_CHIP_INFO_L1D == INDEX_L1D_CACHE_ASSOCIATIVITY);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_ASSOCIATIVITY+HWLOC_SOLARIS_CHIP_INFO_L2I == INDEX_L2I_CACHE_ASSOCIATIVITY);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_ASSOCIATIVITY+HWLOC_SOLARIS_CHIP_INFO_L2D == INDEX_L2D_CACHE_ASSOCIATIVITY);
HWLOC_BUILD_ASSERT(INDEX_L1I_CACHE_ASSOCIATIVITY+HWLOC_SOLARIS_CHIP_INFO_L3 == INDEX_L3_CACHE_ASSOCIATIVITY);
chip_info.cache_associativity[index-INDEX_L1I_CACHE_ASSOCIATIVITY] = val;
}
/* store L2U info in L2D with l2_unified flag */
else if (index == INDEX_L2U_CACHE_SIZE) {
chip_info.cache_size[HWLOC_SOLARIS_CHIP_INFO_L2D] = val;
chip_info.l2_unified = 1;
}
else if (index == INDEX_L2U_CACHE_LINESIZE) {
chip_info.cache_linesize[HWLOC_SOLARIS_CHIP_INFO_L2D] = val;
chip_info.l2_unified = 1;
}
else if (index == INDEX_L2U_CACHE_ASSOCIATIVITY) {
chip_info.cache_associativity[HWLOC_SOLARIS_CHIP_INFO_L2D] = val;
chip_info.l2_unified = 1;
}
/* assume sectored L2 is identical to L2u for size/linesize/associativity */
else if (index == INDEX_SL2_CACHE_SIZE) {
chip_info.cache_size[HWLOC_SOLARIS_CHIP_INFO_L2D] = val;
chip_info.l2_unified = 1;
}
else if (index == INDEX_SL2_CACHE_LINESIZE) {
chip_info.cache_linesize[HWLOC_SOLARIS_CHIP_INFO_L2D] = val;
chip_info.l2_unified = 1;
}
else if (index == INDEX_SL2_CACHE_ASSOCIATIVITY) {
chip_info.cache_associativity[HWLOC_SOLARIS_CHIP_INFO_L2D] = val;
chip_info.l2_unified = 1;
}
}
