inline OutIt print_element_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
{
assert(node->type() == node_element);
// Print element name and attributes, if any
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
*out = Ch('<'), ++out;
out = copy_chars(node->name(), node->name() + node->name_size(), out);
out = print_attributes(out, node, flags);
// If node is childless
if (node->value_size() == 0 && !node->first_node())
{
// Print childless node tag ending
*out = Ch('/'), ++out;
*out = Ch('>'), ++out;
}
else
{
// Print normal node tag ending
*out = Ch('>'), ++out;
// Test if node contains a single data node only (and no other nodes)
xml_node<Ch> *child = node->first_node();
if (!child)
{
// If node has no children, only print its value without indenting
out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
}
else if (child->next_sibling() == 0 && child->type() == node_data)
{
// If node has a sole data child, only print its value without indenting
out = copy_and_expand_chars(child->value(), child->value() + child->value_size(), Ch(0), out);
}
else
{
// Print all children with full indenting
if (!(flags & print_no_indenting))
*out = Ch('\n'), ++out;
out = print_children(out, node, flags, indent + 1);
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
}
// Print node end
*out = Ch('<'), ++out;
*out = Ch('/'), ++out;
out = copy_chars(node->name(), node->name() + node->name_size(), out);
*out = Ch('>'), ++out;
}
return out;
}
int print_children(btree_node * n)
{
int i = 0;
if (n->node_type == 2)
printf(" %*s=%s(%i)\n", n->rank * 5 + 1, n->attr_name,
n->regex, n->rank);
else
printf("%*s %c(%i)\n", n->rank * 5 + 1, "", n->op, n->rank);
for (i = 0; i < n->child_count; i++)
{
print_children(n->childs[i]);
}
return 1;
}
void SurveillanceGraph::print_children(SurveillanceGraphNode* node,int depth) {
if ( node != NULL ) {
node->_depth = depth;
std::cout << std::string(3*depth, '-');
std::cout << " Node: " << node->obstacle_index;
std::cout << " Split: " << node->split_cost;
std::cout << " Block: " << node->incoming_blocking_cost;
std::cout << " Paral: " << node->parallel_cost;
std::cout << " Seq.C: " << node->sequential_cost;
std::cout << " Delay: " << node->delay;
std::cout << " Time: " << node->time;
std::cout << std::endl;
for ( int i = 0; i < node->_n_children; i++ ) {
print_children( node->children[i], depth+1 );
}
}
}
static void print_children(hwloc_topology_t topology, hwloc_obj_t obj,
int depth)
{
char type[32], attr[1024];
unsigned i;
hwloc_obj_type_snprintf(type, sizeof(type), obj, 0);
printf("%*s%s", 2*depth, "", type);
if (obj->os_index != (unsigned) -1)
printf("#%u", obj->os_index);
hwloc_obj_attr_snprintf(attr, sizeof(attr), obj, " ", 0);
if (*attr)
printf("(%s)", attr);
printf("\n");
for (i = 0; i < obj->arity; i++) {
print_children(topology, obj->children[i], depth + 1);
}
}
static void topology_init()
{
topo_topology_init(&topology);
topo_topology_load(topology);
topo_topology_get_info(topology, &topoinfo);
depth = topo_get_type_or_below_depth(topology, TOPO_OBJ_CORE);
cores = topo_get_depth_nbobjs(topology, depth);
fprintf(stderr,
"----------------- Dump toplogy[%ud] info -----------------\n",
cores);
/* Dump the toplogy info */
print_children(topology, topo_get_system_obj(topology), 0);
fprintf(stderr,
"----------------------------------------------------------\n");
}
void print_children(Visual* visual, int level)
{
for (int i = 0; i < level; ++i)
{
Console::get_Out() << " ";
}
Console::get_Out() << visual->GetType()->ToString() << " : ";
Console::get_Out() << "level(" << dynamic_cast<UIElement*>(visual)->get_TreeLevel() << "), ";
Console::get_Out() << "awidth(" << dynamic_cast<UIElement*>(visual)->get_ActualWidth() << "), ";
Console::get_Out() << "aheight(" << dynamic_cast<UIElement*>(visual)->get_ActualHeight() << ")";
Console::get_Out() << endl;
size_t count = visual->GetChildrenCount();
for (size_t i = 0; i < count; ++i)
{
Visual* child = visual->GetChild(i);
print_children(child, level+1);
}
}
/* ----------------------------------------------------------- bus_config --- */
double
RTcmix::bus_config(float p[], int n_args, double pp[])
{
ErrCode err;
int i, j, k, startchan, endchan;
char *str, *instname, *busname;
BusType type;
BusSlot *bus_slot;
char inbusses[80], outbusses[80]; // for verbose message
if (n_args < 2)
die("bus_config", "Wrong number of args.");
bus_slot = new BusSlot;
if (bus_slot == NULL)
return -1.0;
inbusses[0] = outbusses[0] = '\0';
Lock localLock(&bus_slot_lock); // This will unlock when going out of scope.
/* do the old Minc casting rigamarole to get string pointers from a double */
str = DOUBLE_TO_STRING(pp[0]);
instname = strdup(str); // Note: If we exit nonfatally, we have to free.
for (i = 1; i < n_args; i++) {
busname = DOUBLE_TO_STRING(pp[i]);
err = parse_bus_name(busname, &type, &startchan, &endchan);
if (err)
goto error;
switch (type) {
case BUS_IN:
if (bus_slot->in_count > 0) strcat(inbusses, ", ");
strcat(inbusses, busname);
if (bus_slot->auxin_count > 0) {
die("bus_config",
"Can't have 'in' and 'aux-in' buses in same bus_config.");
}
j = bus_slot->in_count;
for (k = startchan; k <= endchan; k++)
bus_slot->in[j++] = k;
bus_slot->in_count += (endchan - startchan) + 1;
/* Make sure max channel count set in rtsetparams can accommodate
the highest input chan number in this bus config.
*/
if (endchan >= NCHANS) {
die("bus_config", "You specified %d channels in rtsetparams,\n"
"but this bus_config requires %d channels.",
NCHANS, endchan + 1);
}
break;
case BUS_OUT:
if (bus_slot->out_count > 0) strcat(outbusses, ", ");
strcat(outbusses, busname);
if (bus_slot->auxout_count > 0) {
die("bus_config",
"Can't have 'out' and 'aux-out' buses in same bus_config.");
}
j = bus_slot->out_count;
for (k = startchan; k <= endchan; k++) {
bus_slot->out[j++] = k;
pthread_mutex_lock(&out_in_use_lock);
OutInUse[k] = YES; // DJT added
pthread_mutex_unlock(&out_in_use_lock);
}
bus_slot->out_count += (endchan - startchan) + 1;
/* Make sure max output chans set in rtsetparams can accommodate
the highest output chan number in this bus config.
*/
if (endchan >= NCHANS) {
die("bus_config", "You specified %d output channels in rtsetparams,\n"
"but this bus_config requires %d channels.",
NCHANS, endchan + 1);
}
break;
case BUS_AUX_IN:
if (bus_slot->auxin_count > 0) strcat(inbusses, ", ");
strcat(inbusses, busname);
if (bus_slot->in_count > 0) {
die("bus_config",
"Can't have 'in' and 'aux-in' buses in same bus_config.");
}
j = bus_slot->auxin_count;
for (k = startchan; k <= endchan; k++)
bus_slot->auxin[j++] = k;
bus_slot->auxin_count += (endchan - startchan) + 1;
break;
case BUS_AUX_OUT:
if (bus_slot->auxout_count > 0) strcat(outbusses, ", ");
strcat(outbusses, busname);
if (bus_slot->out_count > 0) {
die("bus_config",
"Can't have 'out' and 'aux-out' buses in same bus_config.");
}
j = bus_slot->auxout_count;
for (k = startchan; k <= endchan; k++) {
bus_slot->auxout[j++] = k;
pthread_mutex_lock(&aux_out_in_use_lock);
AuxOutInUse[k] = YES;
pthread_mutex_unlock(&aux_out_in_use_lock);
}
bus_slot->auxout_count += (endchan - startchan) + 1;
break;
default:
break;
}
}
err = check_bus_inst_config(bus_slot, YES);
if (!err) {
err = insert_bus_slot(instname, bus_slot);
}
if (err)
// BGG mm -- print an error, don't exit
die("bus_config", "couldn't configure the busses");
// exit(1); /* This is probably what user wants? */
/* Make sure specified aux buses have buffers allocated. */
for (i = 0; i < bus_slot->auxin_count; i++)
allocate_aux_buffer(bus_slot->auxin[i], RTBUFSAMPS);
for (i = 0; i < bus_slot->auxout_count; i++)
allocate_aux_buffer(bus_slot->auxout[i], RTBUFSAMPS);
#ifdef PRINTALL
print_children();
print_parents();
#endif
create_play_order();
#ifdef PRINTPLAY
print_play_order();
#endif
#ifdef DEBUG
err = print_inst_bus_config();
#endif
rtcmix_advise("bus_config", "(%s) => %s => (%s)", inbusses, instname, outbusses);
free(instname);
return 0.0;
error:
free(instname);
die("bus_config", "Cannot parse arguments.");
return -1.0;
}
int main(void)
{
int depth;
unsigned i, n;
unsigned long size;
int levels;
char string[128];
int topodepth;
void *m;
hwloc_topology_t topology;
hwloc_cpuset_t cpuset;
hwloc_obj_t obj;
/* Allocate and initialize topology object. */
hwloc_topology_init(&topology);
/* ... Optionally, put detection configuration here to ignore
some objects types, define a synthetic topology, etc....
The default is to detect all the objects of the machine that
the caller is allowed to access. See Configure Topology
Detection. */
/* Perform the topology detection. */
hwloc_topology_load(topology);
/* Optionally, get some additional topology information
in case we need the topology depth later. */
topodepth = hwloc_topology_get_depth(topology);
/*****************************************************************
* First example:
* Walk the topology with an array style, from level 0 (always
* the system level) to the lowest level (always the proc level).
*****************************************************************/
for (depth = 0; depth < topodepth; depth++) {
printf("*** Objects at level %d\n", depth);
for (i = 0; i < hwloc_get_nbobjs_by_depth(topology, depth);
i++) {
hwloc_obj_type_snprintf(string, sizeof(string),
hwloc_get_obj_by_depth(topology, depth, i), 0);
printf("Index %u: %s\n", i, string);
}
}
/*****************************************************************
* Second example:
* Walk the topology with a tree style.
*****************************************************************/
printf("*** Printing overall tree\n");
print_children(topology, hwloc_get_root_obj(topology), 0);
/*****************************************************************
* Third example:
* Print the number of packages.
*****************************************************************/
depth = hwloc_get_type_depth(topology, HWLOC_OBJ_PACKAGE);
if (depth == HWLOC_TYPE_DEPTH_UNKNOWN) {
printf("*** The number of packages is unknown\n");
} else {
printf("*** %u package(s)\n",
hwloc_get_nbobjs_by_depth(topology, depth));
}
/*****************************************************************
* Fourth example:
* Compute the amount of cache that the first logical processor
* has above it.
*****************************************************************/
levels = 0;
size = 0;
for (obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_PU, 0);
obj;
obj = obj->parent)
if (obj->type == HWLOC_OBJ_CACHE) {
levels++;
size += obj->attr->cache.size;
}
printf("*** Logical processor 0 has %d caches totaling %luKB\n",
levels, size / 1024);
/*****************************************************************
* Fifth example:
* Bind to only one thread of the last core of the machine.
*
* First find out where cores are, or else smaller sets of CPUs if
* the OS doesn't have the notion of a "core".
*****************************************************************/
depth = hwloc_get_type_or_below_depth(topology, HWLOC_OBJ_CORE);
/* Get last core. */
obj = hwloc_get_obj_by_depth(topology, depth,
hwloc_get_nbobjs_by_depth(topology, depth) - 1);
if (obj) {
/* Get a copy of its cpuset that we may modify. */
cpuset = hwloc_bitmap_dup(obj->cpuset);
/* Get only one logical processor (in case the core is
SMT/hyper-threaded). */
hwloc_bitmap_singlify(cpuset);
/* And try to bind ourself there. */
if (hwloc_set_cpubind(topology, cpuset, 0)) {
char *str;
int error = errno;
hwloc_bitmap_asprintf(&str, obj->cpuset);
printf("Couldn't bind to cpuset %s: %s\n", str, strerror(error));
free(str);
}
/* Free our cpuset copy */
hwloc_bitmap_free(cpuset);
}
/*****************************************************************
* Sixth example:
* Allocate some memory on the last NUMA node, bind some existing
* memory to the last NUMA node.
*****************************************************************/
/* Get last node. There's always at least one. */
n = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_NUMANODE);
obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_NUMANODE, n - 1);
size = 1024*1024;
m = hwloc_alloc_membind_nodeset(topology, size, obj->nodeset,
HWLOC_MEMBIND_BIND, 0);
hwloc_free(topology, m, size);
m = malloc(size);
hwloc_set_area_membind_nodeset(topology, m, size, obj->nodeset,
HWLOC_MEMBIND_BIND, 0);
free(m);
/* Destroy topology object. */
hwloc_topology_destroy(topology);
return 0;
}
enum ext_lang_rc
gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang,
struct type *type, const gdb_byte *valaddr,
int embedded_offset, CORE_ADDR address,
struct ui_file *stream, int recurse,
const struct value *val,
const struct value_print_options *options,
const struct language_defn *language)
{
struct gdbarch *gdbarch = get_type_arch (type);
PyObject *printer = NULL;
PyObject *val_obj = NULL;
struct value *value;
char *hint = NULL;
struct cleanup *cleanups;
enum ext_lang_rc result = EXT_LANG_RC_NOP;
enum string_repr_result print_result;
/* No pretty-printer support for unavailable values. */
if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
return EXT_LANG_RC_NOP;
if (!gdb_python_initialized)
return EXT_LANG_RC_NOP;
cleanups = ensure_python_env (gdbarch, language);
/* Instantiate the printer. */
if (valaddr)
valaddr += embedded_offset;
value = value_from_contents_and_address (type, valaddr,
address + embedded_offset);
set_value_component_location (value, val);
/* set_value_component_location resets the address, so we may
need to set it again. */
if (VALUE_LVAL (value) != lval_internalvar
&& VALUE_LVAL (value) != lval_internalvar_component
&& VALUE_LVAL (value) != lval_computed)
set_value_address (value, address + embedded_offset);
val_obj = value_to_value_object (value);
if (! val_obj)
{
result = EXT_LANG_RC_ERROR;
goto done;
}
/* Find the constructor. */
printer = find_pretty_printer (val_obj);
Py_DECREF (val_obj);
if (printer == NULL)
{
result = EXT_LANG_RC_ERROR;
goto done;
}
make_cleanup_py_decref (printer);
if (printer == Py_None)
{
result = EXT_LANG_RC_NOP;
goto done;
}
/* If we are printing a map, we want some special formatting. */
hint = gdbpy_get_display_hint (printer);
make_cleanup (free_current_contents, &hint);
/* Print the section */
print_result = print_string_repr (printer, hint, stream, recurse,
options, language, gdbarch);
if (print_result != string_repr_error)
print_children (printer, hint, stream, recurse, options, language,
print_result == string_repr_none);
result = EXT_LANG_RC_OK;
done:
if (PyErr_Occurred ())
print_stack_unless_memory_error (stream);
do_cleanups (cleanups);
return result;
}
GUIEXT void print_(Visual* visual)
{
print_children(visual, 0);
}
void SurveillanceGraph::print() {
print_children( root,0 );
}