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 ); }