static ssize_t store_control(struct device *d,
struct device_attribute *attr, const char *buf, size_t count)
{
struct modemctl *mc = dev_get_drvdata(d);
if (!strncmp(buf, "on", 2)) {
modem_on(mc);
return count;
}
if (!strncmp(buf, "off", 3)) {
modem_off(mc);
return count;
}
if (!strncmp(buf, "reset", 5)) {
modem_reset(mc);
return count;
}
if (!strncmp(buf, "boot", 4)) {
modem_boot(mc);
return count;
}
if (!strncmp(buf, "renum", 6)) {
enumeration(mc);
return count;
}
if (!strncmp(buf, "phon", 4)) {
gpio_set_value(mc->gpio_phone_on, 0);
mdelay(1);
gpio_set_value(mc->gpio_phone_on, 1);
return count;
}
if (!strncmp(buf, "gsw=0", 5)) {
gpio_set_value(mc->gpio_ipc_slave_wakeup, 0);
return count;
}
if (!strncmp(buf, "gsw=1", 5)) {
gpio_set_value(mc->gpio_ipc_slave_wakeup, 1);
return count;
}
if (!strncmp(buf, "gat=0", 5)) {
gpio_set_value(mc->gpio_active_state, 0);
return count;
}
if (!strncmp(buf, "gat=1", 5)) {
gpio_set_value(mc->gpio_active_state, 1);
return count;
}
return count;
}
void SPGEnumerator::enumeration() {
std::map<int, std::set<int> > curAdjSet;
constructAdjSet(curAdjSet);
std::set<int> edge;
int a, b;
for (std::map<int, std::set<int> >::iterator it = curAdjSet.begin(); it != curAdjSet.end(); it++) {
a = it->first;
for (std::set<int>::iterator sit = (it->second).begin();
sit != (it->second).end(); sit++) {
b = *sit;
edge.clear();
edge.insert(a);
edge.insert(b);
g.addNewEdge(edge, e2n[edge]);
if (graphVisited.find(g.hashEdgeSet()) == graphVisited.end()) {
graphVisited.insert(g.hashEdgeSet());
#ifdef DEBUG
std::cout << "SUB-GRAPH:"<< std::endl;
g.printGraph();
#endif
enumeration();
if (!isSPG) {
spgi.initialization(g.realEdgeSet);
if (spgi.identify()) {
counting();
enumeration();
}
} else {
counting();
enumeration();
}
}
g.removeEdge(edge, e2n[edge]);
}
}
}
void SPGEnumerator::start() {
std::map<int, std::set<int> > curAdjSet;
for (std::set<int>::iterator it = edgeSet.begin(); it != edgeSet.end(); it++) {
g.addNewEdge(n2e[*it], *it);
graphVisited.insert(g.hashEdgeSet());
#ifdef DEBUG
std::cout << "SUB-GRAPH:"<< std::endl;
g.printGraph();
#endif
counting();
enumeration();
g.removeEdge(n2e[*it], *it);
}
}
int main(void)
{
//[enumerate_example
std::shared_ptr<boost::afio::async_file_io_dispatcher_base> dispatcher=
boost::afio::make_async_file_io_dispatcher();
// Schedule an opening of the root directory
boost::afio::async_io_op rootdir(dispatcher->dir(boost::afio::async_path_op_req("/")));
std::pair<std::vector<boost::afio::directory_entry>, bool> list;
// This is used to reset the enumeration to the start
bool restart=true;
do
{
// Schedule an enumeration of an open directory handle
// Note it returns a future to the results and an op ref
std::pair<
boost::afio::future<std::pair<std::vector<boost::afio::directory_entry>, bool>>,
boost::afio::async_io_op
> enumeration(
dispatcher->enumerate(boost::afio::async_enumerate_op_req(
/* This is the handle to enumerate */
rootdir,
/* This is the maximum entries to enumerate. Note
the use of compatibility_maximum() which is the
same value your libc uses. The problem with smaller
enumerations is that the directory contents can change
out from underneath you more frequently. */
boost::afio::directory_entry::compatibility_maximum(),
/* True if to reset enumeration */
restart)));
restart=false;
// People using AFIO often forget that futures can be waited
// on normally without needing to wait on the op handle
list=enumeration.first.get();
for(boost::afio::directory_entry &i : list.first)
{
#ifdef WIN32
std::wcout << i.name();
#else
std::cout << i.name();
#endif
std::cout << " type " << static_cast<int>(i.st_type()) << std::endl;
}
} while(list.second);
//]
}
int main(void){
int minFlipTimes = 0;
int initState = 0;
initState = read();
if(initState == END_STATE_1 || initState == END_STATE_2){
printf("%d",0);
return 0;
}
minFlipTimes = enumeration(&initState);
if(minFlipTimes == 17)
printf("Impossible");
else
printf("%d", minFlipTimes);
return 0;
}
bool usbh_enum_available(void)
{
return !enumeration();
}
oop Profiler::copy_call_graph(oop method_pt, oop block_pt, oop access_pt,
oop prim_pt, oop leaf_pt, oop fold_pt,
oop unknown_oop,
smi cutoff_pct) {
ResourceMark rm;
if ( ProfilerIgnoreCallGraph || !root->edges ) {
// If the call graph is ignored the root contains the
// accumulated timing and allocation information
if (!this->root->edges)
warning("Profiler::copy_call_graph: root edges are NULL, profiled program probably was too brief");
oop node = leaf_pt->clone(CANFAIL);
if (node == failedAllocationOop) return failedAllocationOop;
leaf_node_info* leaf_pt_info = new leaf_node_info(leaf_pt);
leaf_pt_info->fill(node, root);
return node;
}
if ( PrintProfiling ) {
// Old debugging code; checking for multiple roots -- dmu 2/04
int c; float t;
graph_totaller::compute_totals(root_edge, c, t);
lprintf("in copy_call_graph: count = %d, time = %g\n", c, t);
lprintf(" and root and rootedge are ");
{
for (call_graph_edge* e = root_edge; e; e = e->next) {
e->callee->print_node(), lprintf("\n");
for (call_graph_edge* ee = e->callee->edges; ee; ee = ee->next)
lprintf(" "), ee->callee->print_node(), lprintf("\n");
}
}
lprintf("\n\n");
}
// Prepare for the enumeration by collecting all referred maps in the graph.
MapTable graph_maps;
{
ResourceMark rm2;
map_collector collector(this->root->edges, &graph_maps);
_collector = &collector;
switchToVMStack(cont_collect);
}
// Enumerate the maps
{
ResourceMark rm2;
map_enumeration enumeration(&graph_maps);
enumeration.enumerate();
}
graph_creator creator(this->root->edges, &graph_maps,
method_pt, block_pt, access_pt,
prim_pt, leaf_pt, fold_pt, unknown_oop, cutoff_pct);
// Do the recursive graph traversal on the VM stack.
_creator = &creator;
switchToVMStack(cont_copy);
graph_maps.deallocate();
return creator.ran_out_of_memory() ? failedAllocationOop : creator.root();
}
