static int open_TraceWin()
/*success-> return 0;*/
{
int i;
open_window(&win, kTraceWinID);
position_window(&win);
mac_ctl_reset_trc();
for(i = 0; i < 16; i++)
init_bitset(channel_program_flags + i, 128);
return 0;
}
int main(void)
{
int x, i, j;
scanf("%d", &x);
void* bitset = init_bitset(x + 1);
for(i = 2; i * i <= x; i++)
if(!get_bitset(bitset, i))
for(j = i * i; j <= x; j += i)
set_bitset(bitset, j, 1);
int count = 0;
for(i = 2; i <= x; i++)
if(!get_bitset(bitset, i))
count++;
printf("%d", count);
destroy_bitset(bitset);
return 0;
}
/*-------------------------------------------
* A Node coloring routine which does the following
* - Find the next constrained vertex, vIndex (variable Ordering)
* - Test if the `vIndex` vertex is colorable. Return false if not.
* - Find the colors possible for vIndex (Value Ordering of Colors)
* - The colors will be found in the priority order
* - If for a particular color option, one of the ngb of
* vIndex is reduced to zero available colors, then dont consider that
* color. (Impossibility Testing)
* - Spawn a new node state in priority order for each possible color.
* - In that Node state, mark the color of vIndex
* - Update the coloring info for ngbs of vIndex
* - If by coloring vIndex with a particular color
* one of its ngbs reduced to one color possibility,
* then color that vertex as well recursively. (Forced Move)
* ----------------------------------------*/
void Node::colorRemotely(){
#ifdef DEBUG
char *id = new char[nodeID_.size()];
strcpy(id, nodeID_.c_str());
CkPrintf("Color remotely in node [%s] with uncolored num=%d\n", id, uncolored_num_);
delete [] id;
#endif
//-----------------------------------------------
//Detect Subgraphs
//If have >=2 subgraphs, make this node and_node
//and spawn children to color each subgraphs
//----------------------------------------------
//only if some vertices are removed, otherwise
//no new subgraphs will be created
if(doSubgraph){
boost::dynamic_bitset<> init_bitset(vertices_);
init_bitset.set();
//initialize the bitset by marking all removed vertices as 0
//and existed vertices as 1
CkAssert(node_state_.size()==vertices_);
for(int i=0; i<vertices_; i++){
//these vertices have been removed from current graph
if(!node_state_[i].isOperationPermissible())
init_bitset.reset(i);
}
pq_subgraph_type prioritySubgraphs;
//detect subgraphs and create states correspondingly
if(detectAndCreateSubgraphs( init_bitset, prioritySubgraphs ) ){
//#ifdef DEUBG
char * id = new char[nodeID_.size()+1];
strcpy(id, nodeID_.c_str());
CkPrintf("Found %d subgraphs in node[%s]\n", prioritySubgraphs.size(), id);
delete [] id;
//#endif
is_and_node_ = true;
int numChildrenStates = prioritySubgraphs.size();
UShort childBits = _log(numChildrenStates);
while( ! prioritySubgraphs.empty() ){
boost::dynamic_bitset<> subgraph_bitset = prioritySubgraphs.top();
prioritySubgraphs.pop();
std::vector<vertex> new_state = node_state_;
boost::dynamic_bitset<> remove_bitset = init_bitset ^ subgraph_bitset;
#ifdef DEBUG
std::string s;
boost::to_string(subgraph_bitset, s);
char * bits = new char[s.size()+1];
strcpy(bits, s.c_str());
CkPrintf("subgraph bitset: %s\n", bits);
delete [] bits;
#endif
for(int i=0; i<remove_bitset.size(); i++){
if(remove_bitset.test(i)){
new_state[i].set_out_of_subgraph(true);
}
}
if(doPriority){
CkEntryOptions* opts = new CkEntryOptions();
UShort newParentPrioBits; UInt* newParentPrioPtr;
UInt newParentPrioPtrSize;
getPriorityInfo(newParentPrioBits, newParentPrioPtr, newParentPrioPtrSize,
parentBits, parentPtr, childBits, child_num_);
opts->setPriority(newParentPrioBits, newParentPrioPtr);
CProxy_Node::ckNew(new_state, false,
subgraph_bitset.count(), thisProxy,
nodeID_+std::to_string(child_num_),
newParentPrioBits, newParentPrioPtr, newParentPrioPtrSize,
CK_PE_ANY, opts);
free(newParentPrioPtr);
} else {
CProxy_Node::ckNew(new_state, false,
subgraph_bitset.count(), thisProxy,
nodeID_+std::to_string(child_num_),
0, NULL, 0);
}
child_num_++;
}
return;
}
}
// -----------------------------------------
// Following code deals with case is_and_node=false
// -----------------------------------------
int vIndex = this->getNextConstraintVertex();
CkAssert(vIndex!=-1);
boost::dynamic_bitset<> possibleColor = node_state_[vIndex].getPossibleColor();
if(!possibleColor.any()){
parent_.finish(false, node_state_);
return;
}
pq_type priorityColors = getValueOrderingOfColors(vIndex);
int numChildrenStates = priorityColors.size();
UShort childBits = _log(numChildrenStates);
while (! priorityColors.empty()) {
/* priorityColors contains the vertex
* colors (c1 > c2 > c3 ..) in the order governed by the valueOrdering.
* If we are not concerned about prioritization while
* firing chares, i.e. doPriority == false , we can just spawn a chare for each poped
* element of priorityColors. Else if (doPriority == true)
* and say priorityColors has elements c1: c2:c3 (such that c1 > c2 > c3)
* then we have to fire c1, c2 and c3 with priority Ptr00, Ptr01, Ptr10
* respectively, where Ptr is the priority bits for their parent.
*/
std::pair<int,int> p = priorityColors.top();
priorityColors.pop();
std::vector<vertex> new_state = node_state_;
CkAssert(p.first < chromaticNum_);
int verticesColored = updateState(new_state, vIndex, p.first, true);
CkAssert(verticesColored >= 1);
if(doPriority) {
CkEntryOptions* opts = new CkEntryOptions ();
UShort newParentPrioBits; UInt* newParentPrioPtr;
UInt newParentPrioPtrSize;
getPriorityInfo(newParentPrioBits, newParentPrioPtr, newParentPrioPtrSize, parentBits, parentPtr, childBits, child_num_);
opts->setPriority(newParentPrioBits, newParentPrioPtr);
CProxy_Node::ckNew(new_state, false, uncolored_num_- verticesColored,
thisProxy, nodeID_ + std::to_string(child_num_), newParentPrioBits, newParentPrioPtr,
newParentPrioPtrSize, CK_PE_ANY , opts);
child_num_ ++;
free(newParentPrioPtr);
} else {
CProxy_Node::ckNew(new_state, false, uncolored_num_- verticesColored,
thisProxy, nodeID_ + std::to_string(child_num_), 0, NULL, 0);
child_num_ ++;
}
}
}
