// // Function: shrink() // // Purpose: Uniformly shrinks this member func around it's center // // Arguments: // // int x_delta - how much to shrink the member func by // // Returns: // // void // // Author: Michael Zarozinski // Date: 9/99 // // Modification History // Author Date Modification // ------ ---- ------------ // // void MemberFuncTri::shrink(int x_delta ) { int delta = abs(x_delta); move_node(0, nodes[0].x + delta, nodes[0].y); move_node(2, nodes[2].x - delta, nodes[2].y); } // end MemberFuncTri::shrink()
/* Push nodes from source to aRef and bRef alternatively */ void alternating_split(struct node* source, struct node** aRef, struct node** bRef) { *aRef = NULL; *bRef = NULL; while(source!=NULL) { move_node(aRef, &source); if(source!=NULL) move_node(bRef, &source); } }
struct node *sort_merge(struct node *list1, struct node *list2) { struct node *result; struct node **result_ref = &result; while (1) { if (list1 == NULL) { *result_ref = list2; break; } if (list2 == NULL) { *result_ref = list1; break; } if (list1->data < list2->data) { move_node(result_ref, &list1); } else { move_node(result_ref, &list2); } result_ref = &((*result_ref)->next); } return result; }
/* Merge the nodes of the two lists into a single list taking a node alternately from each list, and return the new list. */ struct node* shuffle_merge(struct node* plista, struct node* plistb) { struct node* phead = NULL; struct node** ref_plast = &phead; while(plista != NULL || plistb != NULL) { if(plista != NULL) { move_node(ref_plast, &plista); ref_plast = &((*ref_plast)->next); } else { *ref_plast = plistb; break; } if(plistb != NULL) { move_node(ref_plast, &plistb); ref_plast = &((*ref_plast)->next); } else { *ref_plast = plista; break; } } return phead; }
// // Function: move() // // Purpose: Moves ALL the nodes for the member func by the delta passed in. // // Arguments: // // int x_delta - how many 'x' elements (in the values[] array) to move each node by // // Returns: // // void // // Author: Michael Zarozinski // Date: 7/99 // // Modification History // Author Date Modification // ------ ---- ------------ // // void MemberFuncBase::move(int x_delta) { if (x_delta == 0) return; // nothing to do! // move all the nodes... // we need to be careful about the order we move them in. // if they are being move to the right (positive offset) we need to // move the last point and work our way to the first point so we don't // cross any points if the offset is large. // likewize if we're moving to the left (negative offset) move them in // order (first to last) int start, end, increment; // values that determine how we loop int node_count = get_node_count(); if (x_delta < 0) { // moving to the left start = 0; end = node_count; increment = 1; // adjust the delta so we don't "collapse" the term if (nodes[0].x + x_delta < 0) x_delta = -nodes[0].x; } // end if offset negative else { // offset is positive start = node_count - 1; end = -1; increment = -1; if (nodes[node_count - 1].x + x_delta > FuzzyVariableBase::get_x_array_max_idx()) x_delta = ( FuzzyVariableBase::get_x_array_max_idx()) - nodes[node_count - 1].x; } // end if offset positive // now move them all (note the 'y' direction is invariant when moving all nodes at once) for (int i = start; i != end; i += increment) { move_node(i, nodes[i].x + x_delta, nodes[i].y ); } // end loop through nodes } // end MemberFuncBase::move()
int main() { struct node *plista = create_list(); struct node *plistb = create_list(); print(plista); print(plistb); move_node(&plista, &plistb); printf("after move_head:\n"); print(plista); print(plistb); printf("\n"); return 0; }
struct node* sorted_merge(struct node* a, struct node* b) { struct node* returned = NULL; if(a==NULL && b==NULL) return NULL; else if(a!=NULL && b==NULL) { returned = sorted_merge(a->next, NULL); move_node(&returned, &a); } else if(a==NULL && b!=NULL) { returned = sorted_merge(NULL, b->next); move_node(&returned, &b); } else if(a!=NULL && b!=NULL) { if(b->data <= a->data) { returned = sorted_merge(a, b->next); b->next == NULL; move_node(&returned,&b); //a->next == NULL; //move_node(&returned,&a); } else { returned = sorted_merge(a->next, b); a->next == NULL; move_node(&returned,&a); //b->next == NULL; //move_node(&returned,&b); } } return returned; }
/* This function does no error check. You must check and ensure this function must not fail before calling. */ static void move_conflicts_real(dary *da, const int *conflicts, int move_to) { int i = 0; int offsets[257]; int parent_index = get_parent_index(da, conflicts[0]); calc_offsets(conflicts, offsets); da->base[parent_index] = move_to - (conflicts[0] - da->base[parent_index]); for (i = 0; conflicts[i] != -1; i++) { move_node(da, conflicts[i], move_to + offsets[i]); } // dary_dump(da); }
void main() { struct node* head = BuildOneTwoThree(); print_list(head); // int count = Count(head, 2); // int count = get_nth(head, 0); // printf("Count is: %d\n", count); // delete_list(&head); // print_list(head); // int i = 0; // int length = list_length(head); /* for(i = 0; i<length; i++) { int c = pop(&head); printf("%d\t", c); } printf("\n"); */ // insert_nth(&head,0,10); // print_list(head); #ifdef SORTED_INSERT struct node* new_node1 = (struct node*) malloc(sizeof(struct node)); new_node1->data = 13; sorted_insert(&head, new_node1); print_list(head); struct node* new_node2 = (struct node*) malloc(sizeof(struct node)); new_node2->data = 0; sorted_insert(&head, new_node2); print_list(head); struct node* new_node3 = (struct node*) malloc(sizeof(struct node)); new_node3->data = 8; sorted_insert(&head, new_node3); print_list(head); struct node* new_node4 = (struct node*) malloc(sizeof(struct node)); new_node4->data = 4; sorted_insert(&head, new_node4); print_list(head); struct node* new_node5 = (struct node*) malloc(sizeof(struct node)); new_node5->data = 30; sorted_insert(&head, new_node5); print_list(head); #endif #ifdef INSERT_SORT insert_nth(&head,0,10); insert_nth(&head,1,20); insert_nth(&head,3,14); insert_nth(&head,4,78); insert_nth(&head,1,32); insert_nth(&head,3,42); print_list(head); insert_sort(&head); print_list(head); #endif #ifdef APPEND struct node* head1 = BuildOneTwoThree(); insert_nth(&head1,0,10); print_list(head1); append(&head,&head1); print_list(head); print_list(head1); #endif #ifdef SPLIT_FRONT_BACK struct node* new_node5 = (struct node*) malloc(sizeof(struct node)); new_node5->data = 30; sorted_insert(&head, new_node5); struct node* new_node6 = (struct node*) malloc(sizeof(struct node)); new_node6->data = 10; sorted_insert(&head, new_node6); struct node* head1 = NULL; struct node* head2=NULL; front_back_split(head, &head1, &head2); print_list(head1); print_list(head2); #endif #ifdef REMOVE_DUPLICATES struct node* new_node5 = (struct node*) malloc(sizeof(struct node)); new_node5->data = 2; sorted_insert(&head, new_node5); struct node* new_node6 = (struct node*) malloc(sizeof(struct node)); new_node6->data = 1; sorted_insert(&head, new_node6); print_list(head1); remove_duplicates(head1); print_list(head1); #endif #ifdef MOV_NODE struct node* a = BuildOneTwoThree(); struct node* b = BuildOneTwoThree(); print_list(a); print_list(b); move_node(&a,&b); print_list(a); print_list(b); #endif #ifdef ALTERNATING_SPLIT struct node* a = NULL; struct node* b = NULL; alternating_split(head, &a, &b); print_list(a); print_list(b); #endif #ifdef SHUFFLE_MERGE struct node* a = BuildOneTwoThree(); struct node* b = BuildOneTwoThree(); print_list(a); print_list(b); struct node* c = shuffle_merge(a,b); print_list(c); #endif #ifdef SORTED_MERGE struct node* a = BuildOneTwoThree(); struct node* b = BuildOneTwoThree(); struct node* new_node1 = (struct node*) malloc(sizeof(struct node)); new_node1->data = 13; sorted_insert(&a, new_node1); struct node* new_node2 = (struct node*) malloc(sizeof(struct node)); new_node2->data = 0; sorted_insert(&b, new_node2); struct node* new_node3 = (struct node*) malloc(sizeof(struct node)); new_node3->data = 8; sorted_insert(&a, new_node3); struct node* new_node4 = (struct node*) malloc(sizeof(struct node)); new_node4->data = 4; sorted_insert(&a, new_node4); struct node* new_node5 = (struct node*) malloc(sizeof(struct node)); new_node5->data = 30; sorted_insert(&b, new_node5); print_list(a); print_list(b); struct node* c = sorted_merge(a,b); print_list(c); #endif #ifdef MERGE_SORT insert_nth(&head,0,10); insert_nth(&head,1,20); insert_nth(&head,3,14); insert_nth(&head,4,78); insert_nth(&head,1,32); insert_nth(&head,3,42); print_list(head); merge_sort(&head); // print_list(head); #endif insert_nth(&head,0,10); insert_nth(&head,1,20); insert_nth(&head,3,14); insert_nth(&head,4,78); insert_nth(&head,1,32); insert_nth(&head,3,42); print_list(head); reverse(&head); print_list(head); }
EdgeWeight two_way_fm::perform_refinement(PartitionConfig & cfg, graph_access& G, complete_boundary & boundary, std::vector<NodeID> & lhs_start_nodes, std::vector<NodeID> & rhs_start_nodes, boundary_pair * pair, NodeWeight & lhs_part_weight, NodeWeight & rhs_part_weight, EdgeWeight & cut, bool & something_changed) { PartitionConfig config = cfg;//copy it since we make changes on that if(lhs_start_nodes.size() == 0 or rhs_start_nodes.size() == 0) return 0; // nothing to refine quality_metrics qm; ASSERT_NEQ(pair->lhs, pair->rhs); ASSERT_TRUE(assert_directed_boundary_condition(G, boundary, pair->lhs, pair->rhs)); ASSERT_EQ( cut, qm.edge_cut(G, pair->lhs, pair->rhs)); refinement_pq* lhs_queue = NULL; refinement_pq* rhs_queue = NULL; if(config.use_bucket_queues) { EdgeWeight max_degree = G.getMaxDegree(); lhs_queue = new bucket_pq(max_degree); rhs_queue = new bucket_pq(max_degree); } else { lhs_queue = new maxNodeHeap(); rhs_queue = new maxNodeHeap(); } init_queue_with_boundary(config, G, lhs_start_nodes, lhs_queue, pair->lhs, pair->rhs); init_queue_with_boundary(config, G, rhs_start_nodes, rhs_queue, pair->rhs, pair->lhs); queue_selection_strategy* topgain_queue_select = new queue_selection_topgain(config); queue_selection_strategy* diffusion_queue_select = new queue_selection_diffusion(config); queue_selection_strategy* diffusion_queue_select_block_target = new queue_selection_diffusion_block_targets(config); vertex_moved_hashtable moved_idx; std::vector<NodeID> transpositions; EdgeWeight inital_cut = cut; int max_number_of_swaps = (int)(boundary.getBlockNoNodes(pair->lhs) + boundary.getBlockNoNodes(pair->rhs)); int step_limit = (int)((config.fm_search_limit/100.0)*max_number_of_swaps); step_limit = std::max(step_limit, 15); int min_cut_index = -1; refinement_pq* from_queue = 0; refinement_pq* to_queue = 0; PartitionID from = 0; PartitionID to = 0; NodeWeight * from_part_weight = 0; NodeWeight * to_part_weight = 0; stop_rule* st_rule = new easy_stop_rule(); partition_accept_rule* accept_partition = NULL; if(config.initial_bipartitioning) { accept_partition = new ip_partition_accept_rule(config, cut,lhs_part_weight, rhs_part_weight, pair->lhs, pair->rhs); } else { accept_partition = new normal_partition_accept_rule(config, cut,lhs_part_weight, rhs_part_weight); } queue_selection_strategy* q_select; if(config.softrebalance || config.rebalance || config.initial_bipartitioning) { if(config.initial_bipartitioning) { q_select = diffusion_queue_select_block_target; } else { q_select = diffusion_queue_select; } } else { q_select = topgain_queue_select; } //roll forwards EdgeWeight best_cut = cut; int number_of_swaps = 0; for(number_of_swaps = 0; number_of_swaps < max_number_of_swaps; number_of_swaps++) { if(st_rule->search_should_stop(min_cut_index, number_of_swaps, step_limit)) break; if(lhs_queue->empty() && rhs_queue->empty()) { break; } q_select->selectQueue(lhs_part_weight, rhs_part_weight, pair->lhs, pair->rhs, from,to, lhs_queue, rhs_queue, &from_queue, &to_queue); if(!from_queue->empty()) { Gain gain = from_queue->maxValue(); NodeID node = from_queue->deleteMax(); ASSERT_TRUE(moved_idx[node].index == NOT_MOVED); boundary.setBlockNoNodes(from, boundary.getBlockNoNodes(from)-1); boundary.setBlockNoNodes(to, boundary.getBlockNoNodes(to)+1); if(from == pair->lhs) { from_part_weight = &lhs_part_weight; to_part_weight = &rhs_part_weight; } else { from_part_weight = &rhs_part_weight; to_part_weight = &lhs_part_weight; } move_node(config, G, node, moved_idx, from_queue, to_queue, from, to, pair, from_part_weight, to_part_weight, boundary); cut -= gain; if( accept_partition->accept_partition(config, cut, lhs_part_weight, rhs_part_weight, pair->lhs, pair->rhs, config.rebalance)) { ASSERT_TRUE( cut <= best_cut || config.rebalance); if( cut < best_cut ) { something_changed = true; } best_cut = cut; min_cut_index = number_of_swaps; } transpositions.push_back(node); moved_idx[node].index = MOVED; } else { break; } } ASSERT_TRUE(assert_directed_boundary_condition(G, boundary, pair->lhs, pair->rhs)); ASSERT_EQ( cut, qm.edge_cut(G, pair->lhs, pair->rhs)); //roll backwards for(number_of_swaps--; number_of_swaps > min_cut_index; number_of_swaps--) { ASSERT_TRUE(transpositions.size() > 0); NodeID node = transpositions.back(); transpositions.pop_back(); PartitionID nodes_partition = G.getPartitionIndex(node); if(nodes_partition == pair->lhs) { from_queue = lhs_queue; to_queue = rhs_queue; from = pair->lhs; to = pair->rhs; from_part_weight = &lhs_part_weight; to_part_weight = &rhs_part_weight; } else { from_queue = rhs_queue; to_queue = lhs_queue; from = pair->rhs; to = pair->lhs; from_part_weight = &rhs_part_weight; to_part_weight = &lhs_part_weight; } boundary.setBlockNoNodes(from, boundary.getBlockNoNodes(from)-1); boundary.setBlockNoNodes(to, boundary.getBlockNoNodes(to)+1); move_node_back(config, G, node, moved_idx, from_queue, to_queue, from, to, pair, from_part_weight, to_part_weight, boundary); } //clean up cut = best_cut; boundary.setEdgeCut(pair, best_cut); boundary.setBlockWeight(pair->lhs, lhs_part_weight); boundary.setBlockWeight(pair->rhs, rhs_part_weight); delete lhs_queue; delete rhs_queue; delete topgain_queue_select; delete diffusion_queue_select; delete diffusion_queue_select_block_target; delete st_rule; delete accept_partition; ASSERT_EQ( cut, qm.edge_cut(G, pair->lhs, pair->rhs)); ASSERT_TRUE(assert_directed_boundary_condition(G, boundary, pair->lhs, pair->rhs)); ASSERT_TRUE( (int)inital_cut-(int)best_cut >= 0 || cfg.rebalance); // the computed partition shouldnt have a edge cut which is worse than the initial one return inital_cut-best_cut; }
void MemberFuncBase::move_node(int idx, _point pt) { move_node(idx, pt.x, pt.y); };
void my_callback(u_char *useless,const struct pcap_pkthdr* pkthdr,const u_char* packet) { packet_num++; packet_len+=pkthdr->caplen; static int count = 0; //static int nn=0; static int i; static unsigned short eth_type; static int vlan_flag=0; //sem_getvalue(&shmp[i]->sem,&semnum); //printf("sem:%d\n",semnum); //usleep(1000); static int semnum; // sem_getvalue(&bin_sem,&semnum); // printf("sem:%d\n",semnum); //printf("mmmmmmmmmmmmmm\n"); if(exitflag) { /*for(i=0;i<snortnum;++i) { memcpy(shmp[i]->data[shmp[i]->tail],"########",strlen("########")); shmp[i]->tail=(shmp[i]->tail+1)%shmp[i]->looplen; my_lock_release(shmp[i]); } sleep(4); for(i=0;i<snortnum;++i) { destroy_loop(shmp[i]); DeleteShm(shmid[i]); }*/ for(i=0;i<PRO_MAX+2;++i) { printf("%s:%lld\n",pro_map[i],pronum[i]); } printf("losepacket=%lld\n",losepacket); //sem_post(&bin_sem); NS_TIME_END(time); speed1(NS_GET_TIMEP(time),packet_num,packet_len); printf("count=%d,\nfind_pro=%lld\n",count,find_pro); printf("exit\n"); del_HB(&hb); acsmFree (acsm); // exitflag=0; exit(0); } //return; mac=(struct ether_header*)packet; eth_type=ntohs(mac->ether_type); if((eth_type==0x8100)) { vlan_flag=1; //msg("W:****0X%04X\n",eth_type); eth_type=(packet[16])*256+packet[17]; } else vlan_flag=0; // msg("W:0X%04X\n",eth_type); if((eth_type!=0x0800))//不是ip数据报 return; if(vlan_flag) ip=(struct ip*)(packet+size_mac+4); else ip=(struct ip*)(packet+size_mac); /*char ipdotdecs[20]={0}; char ipdotdecc[20]={0}; inet_ntop(AF_INET,(void*)&(ip->ip_src),ipdotdecs,16); inet_ntop(AF_INET,(void*)&(ip->ip_dst),ipdotdecc,16);*/ //printf("%s-->%s: len:%d\n",ipdotdecs,ipdotdecc,pkthdr->caplen); if((ip->ip_p==6))//tcp { // msg("EIStcp\n"); //tcp=(struct fniff_tcp*)(packet+size_mac+size_ip); tcp=(struct fniff_tcp*)((char*)ip+size_ip); sd.b_ip=(ip->ip_src.s_addr); sd.l_ip=(ip->ip_dst.s_addr); if(sd.b_ip>sd.l_ip) { sd.b_port=ntohs(tcp->th_sport); sd.l_port=ntohs(tcp->th_dport); } else { sd.b_ip^=sd.l_ip; sd.l_ip^=sd.b_ip; sd.b_ip^=sd.l_ip; sd.b_port=ntohs(tcp->th_dport); sd.l_port=ntohs(tcp->th_sport); } hash=hash_HB(sd.b_ip,sd.b_port,sd.l_ip,sd.l_port); tcplen=ntohs(ip->ip_len)-(ip->ip_hl*4)-(tcp->th_off*4); // msg("EIStcp11111111111\n"); // printf("ntohs(ip->ip_len)=%d\n",ntohs(ip->ip_len)+14); // packet.tcp_URG=tcp->th_flags&TH_URG; ack=tcp->th_flags&TH_ACK; // packet.tcp_PSH=tcp->th_flags&TH_PUSH; rst=tcp->th_flags&TH_RST; syn=tcp->th_flags&TH_SYN; fin=tcp->th_flags&TH_FIN; datalen=pkthdr->caplen; ptcp=(unsigned char*)tcp+(tcp->th_off*4); temp=find_node(hb[hash].virtual_sn,&sd); if(temp==NULL&&syn&&!ack&&tcplen==0)//not find { //msg("E no\n"); SN* q=get_node(); q->sdipport=sd; q->state=1; insert_node(&(hb[hash].virtual_sn),q); hb[hash].virtual_sn_num++; //msg("**********=%ld\n",hb[hash].virtual_sn_num); #if 0 if(sd.b_port==21||sd.l_port==21) { q->state=10; pronum[FTP]++; } else if(sd.b_port==80||sd.l_port==80) { q->state=10; pronum[HTTP]++; } memcpy(fortest,packet,pkthdr->caplen); #endif } else if(temp!=NULL) { // printf("state:%d\n",temp->state); if((temp->state==1)&&syn&&ack&&(tcplen==0)) { //msg("W:my ooooooooooooooooooo\n"); temp->state=2; } else if(temp->state==2&&ack&&!syn&&tcplen==0) { temp->state=3; //msg("W:its ===============================static\n"); //msg("W:my hash:%u\n",hash); } else if(temp->state>=3&&temp->state<9) { //if(tcplen==0) // return; //msg("W:my hash:%u\n",hash); //msg("+++++\n"); //msg("ttttttttttttt\n"); p=get_BC_node(); //msg("mmmmmmmmm\n"); if(p==NULL) {msg("EISget bc node error\n");exit(0);} p->datalen=pkthdr->caplen; p->tcplen=tcplen; //msg("tcplen=%d,pkthdr->caplen=%d\n",tcplen,pkthdr->caplen); if(tcplen<0) { msg("EIS tcp<0\n"); exit(0); } p->next=NULL; memcpy(p->buf,packet,pkthdr->caplen); p->ptcp=(unsigned char*)(p->buf)+(tcp->th_off*4)+((unsigned char*)tcp-(unsigned char*)mac);//ptcp; temp->tcp_content_len+=tcplen; if(temp->bc_head==NULL) { temp->bc_head=temp->bc_tail=p; } else { temp->bc_tail->next=p; temp->bc_tail=p; } temp->state++; if((temp->state==9)||rst||fin||(temp->tcp_content_len>150)) { //msg("EIS static\n"); #if 0 p=temp->bc_head; while(p!=NULL) { if(p->tcplen!=0) acsmSearch(acsm,p->ptcp,p->tcplen,PrintMatch); p=p->next; } #else acSearch(acsm,temp->bc_head); acSearch(acsm,temp->bc_head); #endif i=getSummary(acsm->acsmPatterns,feature_num); pronum[i]++; temp->proto=i; if(rst||fin) { temp->state=10; resume_BC_node(temp->bc_head); resume_node(temp); hb[hash].virtual_sn_num--; //msg("*********=%ld\n",hb[hash].virtual_sn_num); if(hb[hash].virtual_sn_num==0) hb[hash].virtual_sn=NULL; return; } temp->state=10; resume_BC_node(temp->bc_head); temp->bc_head=NULL; temp->bc_tail=NULL; } } else if(temp->state>=10) { if(rst||fin) { //resume_node(temp); move_node(&(hb[hash].virtual_sn),temp); hb[hash].virtual_sn_num--; //msg("**************=%ld\n",hb[hash].virtual_sn_num); if(hb[hash].virtual_sn_num==0) hb[hash].virtual_sn=NULL; return; } } else { msg("ggggggggggg\n"); } } }//tcp else if(ip->ip_p==1)//icmp { //printf("2222\n"); //static char pro_map[PRO_MAX+2][20]={"HTTP","FTP","POP3","SMTP","UNKOWN","UDP","ICMP"}; pronum[PRO_MAX+1]++; } else if(ip->ip_p==17)//udp { //printf("1111111\n"); pronum[PRO_MAX]++; } else { printf("no\n"); } }
EdgeWeight kway_graph_refinement_core::single_kway_refinement_round_internal(PartitionConfig & config, graph_access & G, complete_boundary & boundary, boundary_starting_nodes & start_nodes, int step_limit, vertex_moved_hashtable & moved_idx, bool compute_touched_partitions, std::unordered_map<PartitionID, PartitionID> & touched_blocks) { commons = kway_graph_refinement_commons::getInstance(config); refinement_pq* queue = NULL; if(config.use_bucket_queues) { EdgeWeight max_degree = G.getMaxDegree(); queue = new bucket_pq(max_degree); } else { queue = new maxNodeHeap(); } init_queue_with_boundary(config, G, start_nodes, queue, moved_idx); if(queue->empty()) {delete queue; return 0;} std::vector<NodeID> transpositions; std::vector<PartitionID> from_partitions; std::vector<PartitionID> to_partitions; int max_number_of_swaps = (int)(G.number_of_nodes()); int min_cut_index = -1; EdgeWeight cut = std::numeric_limits<int>::max()/2; // so we dont need to compute the edge cut EdgeWeight initial_cut = cut; //roll forwards EdgeWeight best_cut = cut; int number_of_swaps = 0; int movements = 0; kway_stop_rule* stopping_rule = NULL; switch(config.kway_stop_rule) { case KWAY_SIMPLE_STOP_RULE: stopping_rule = new kway_simple_stop_rule(config); break; case KWAY_ADAPTIVE_STOP_RULE: stopping_rule = new kway_adaptive_stop_rule(config); break; } for(number_of_swaps = 0, movements = 0; movements < max_number_of_swaps; movements++, number_of_swaps++) { if( queue->empty() ) break; if( stopping_rule->search_should_stop(min_cut_index, number_of_swaps, step_limit) ) break; Gain gain = queue->maxValue(); NodeID node = queue->deleteMax(); #ifndef NDEBUG PartitionID maxgainer; EdgeWeight ext_degree; ASSERT_TRUE(moved_idx[node].index == NOT_MOVED); ASSERT_EQ(gain, commons->compute_gain(G, node, maxgainer, ext_degree)); ASSERT_TRUE(ext_degree > 0); #endif PartitionID from = G.getPartitionIndex(node); bool successfull = move_node(config, G, node, moved_idx, queue, boundary); if(successfull) { cut -= gain; stopping_rule->push_statistics(gain); bool accept_equal = random_functions::nextBool(); if( cut < best_cut || ( cut == best_cut && accept_equal )) { best_cut = cut; min_cut_index = number_of_swaps; if(cut < best_cut) stopping_rule->reset_statistics(); } from_partitions.push_back(from); to_partitions.push_back(G.getPartitionIndex(node)); transpositions.push_back(node); } else { number_of_swaps--; //because it wasnt swaps } moved_idx[node].index = MOVED; ASSERT_TRUE(boundary.assert_bnodes_in_boundaries()); ASSERT_TRUE(boundary.assert_boundaries_are_bnodes()); } ASSERT_TRUE(boundary.assert_bnodes_in_boundaries()); ASSERT_TRUE(boundary.assert_boundaries_are_bnodes()); //roll backwards for(number_of_swaps--; number_of_swaps>min_cut_index; number_of_swaps--) { ASSERT_TRUE(transpositions.size() > 0); NodeID node = transpositions.back(); transpositions.pop_back(); PartitionID to = from_partitions.back(); from_partitions.pop_back(); to_partitions.pop_back(); move_node_back(config, G, node, to, moved_idx, queue, boundary); } //reconstruct the touched partitions if(compute_touched_partitions) { ASSERT_EQ(from_partitions.size(), to_partitions.size()); for(unsigned i = 0; i < from_partitions.size(); i++) { touched_blocks[from_partitions[i]] = from_partitions[i]; touched_blocks[to_partitions[i]] = to_partitions[i]; } } ASSERT_TRUE(boundary.assert_bnodes_in_boundaries()); ASSERT_TRUE(boundary.assert_boundaries_are_bnodes()); delete queue; delete stopping_rule; return initial_cut - best_cut; }
static dary_status move_conflicts2(dary *da, int n, uchar k) { int conflicts[256+1], move_to; /* MAX conflicts 256, +1 is for termination */ int retcode; int i = 0; get_children(da, n, conflicts); dprint("da->base[%d] =%d, k = %d", n, da->base[n], k); // ここはなんとか関数化できないか? if (conflicts[0] < da->base[n] + k) { while (conflicts[i] != -1) { i++; } dprint("last node is k"); conflicts[i] = da->base[n] + k; conflicts[i+1] = -1; } else { int len = length(conflicts); memmove(&conflicts[1], conflicts, (len + 1) * sizeof(int)); conflicts[0] = da->base[n] + k; dprint("first node is k"); } i = 0; while (conflicts[i] != -1) { dprint("conflicts[%d] = %d", i, conflicts[i]); i++; } retcode = find_movable_location(da, conflicts, &move_to); if (retcode != DARY_STATUS_SUCCESS) { dprint("move_conflicts:Could not found movable location. Retrying...\n"); retcode = extend_array(da, da->length + 256); if (retcode != DARY_STATUS_SUCCESS) { return retcode; } /* This find_movable_loc must be success, but ensure return value to make sure. */ retcode = find_movable_location(da, conflicts, &move_to); if (retcode != DARY_STATUS_SUCCESS) { return retcode; } } i = 0; int offsets[257]; calc_offsets(conflicts, offsets); for (i = 0; conflicts[i] != -1; i++) { if (conflicts[i] != da->base[n] + k) { move_node(da, conflicts[i], move_to + offsets[i]); } } da->base[n] = move_to - (conflicts[0] - da->base[n]); dprint("da->base[%d] = da->base[%d] (%d) + move_to %d - %d = %d", n, n, da->base[n], move_to, conflicts[0], da->base[n] + (move_to - conflicts[0])); return DARY_STATUS_SUCCESS; }