コード例 #1
0
ファイル: server.c プロジェクト: BuddhaLabs/dns2tcp-OSX
int		delete_client(t_conf *conf, t_simple_list *client)
{
  t_simple_list	*tmp;

  if (conf->client == client)
    {
      tmp = client->next;
      LOG("delete_client 0x%x %s\n", client->session_id, 
	  client->control.authenticated ? "" : "(not authenticated)");
      delete_queue(client->saved_queue);      
      list_destroy_simple_cell(conf->client);
      conf->client = tmp;
      return (0);
    }
  for (tmp = conf->client; tmp; tmp = tmp->next)
    {
      if (tmp->next == client)
	{
	  tmp->next = client->next;
	  LOG("delete_client 0x%x\n", client->session_id);
	  delete_queue(client->saved_queue);
	  return (list_destroy_simple_cell(client));
	}
    }
  return (-1);
}
コード例 #2
0
ファイル: server.c プロジェクト: qq273999947/Linux
int server()
{
    int msg_id = creat_queue();
    if(msg_id < 0){
        printf("%s\n",strerror(errno));
        return -1;
    }
    char buf[_SIZE_];
    while(1)
    {
        sleep(5);
        memset(buf,'\0',sizeof(buf));
        int ret = recv_msg(msg_id,CLIENT_TYPE,buf,sizeof(buf));
        if(ret == 0){
            if(strncasecmp(buf,"quit",4) == 0){
                printf("client leave!\n");
                break;
            }
            printf("client say : %s\n",buf);
        }
        printf("Please Enter :");
        fflush(stdout);
        memset(buf,'\0',sizeof(buf));
        scanf("%s",buf);
        send_msg(msg_id,SERVER_TYPE,buf);
    }
    return delete_queue(msg_id);
}
コード例 #3
0
TEST(PRIORITY_QUEUE,FULL){
	
	//try to get the full status of a non existent queue
	RESULT result = is_full(424234);
	EXPECT_EQ(result.code,TICKET_INVALID);
	
	//fill up the queue
	WELCOME_PACKET packet = create_queue();
	
	//if(packet.result.code == SUCCESS){
		
	for(int i = 0; i < MAXIMUM_NUMBER_OF_ELEMENTS_IN_A_QUEUE-1; i++){
		ELEMENT e = {i,i%10};
		EXPECT_EQ(enqueue(e,packet.ticket).code,SUCCESS);
		EXPECT_EQ(is_full(packet.ticket).code,QUEUE_IS_NOT_FULL);
	}
	
	ELEMENT e = {3,3};		
	enqueue(e,packet.ticket);
	
	EXPECT_EQ(is_full(packet.ticket).code,QUEUE_IS_FULL);
	
	enqueue(e,packet.ticket);
	EXPECT_EQ(is_full(packet.ticket).code,QUEUE_IS_FULL);
	

	enqueue(e,packet.ticket);
	EXPECT_EQ(is_full(packet.ticket).code,QUEUE_IS_FULL);
	
	//delete the queue then try to get the full status
	delete_queue(packet.ticket);
	EXPECT_EQ(is_full(packet.ticket).code,TICKET_INVALID);
	
}
コード例 #4
0
ファイル: test_file.c プロジェクト: nejmd/JPEG
int main()
{
        struct priority_queue *queue = create_queue(10);

        if (queue == NULL)
                printf("create_queue error\n");

        insert_queue(queue, 10, (struct huff_table*)10);
        insert_queue(queue, 11, (struct huff_table*)11);
        insert_queue(queue, 8, (struct huff_table*)8);
        insert_queue(queue, 3, (struct huff_table*)3);
        insert_queue(queue, 7, (struct huff_table*)7);
        insert_queue(queue, 15, (struct huff_table*)15);

        uint32_t priority = 0;
        struct huff_table *table = NULL;

        while (best_queue(queue, &priority, &table)) {

                printf("Table = %ld\n", (uint64_t)table);
                delete_queue(queue);
        }

        free_queue(queue);


        return EXIT_SUCCESS;
}
コード例 #5
0
ファイル: P7_6c.c プロジェクト: arunimamookherjee/git_demo
void BFS(int v)
{
	int i;
	
	insert_queue(v);
	state[v] = waiting;
	
	while(!isEmpty_queue())
	{
		v = delete_queue();
		printf("Vertex %d visited\n",v);
		state[v] = visited;
		for(i=0; i<n; i++)
		{
			/* Check for adjacent unvisited vertices */
			if(adj[v][i] == 1 && state[i] == initial) 
			{
				insert_queue(i);
				state[i] = waiting;
				printf("-----Tree edge - (%d,%d)\n", v, i);
			}
		}
	}
	printf("\n");
}/*End of BFS()*/
コード例 #6
0
ファイル: packet_capture.c プロジェクト: Darma/trema
static void *
capture_main( void *args ) {
  UNUSED( args );

  info( "Starting packet capture ( interface_name = %s ).", interface_name );

  packet_queue = create_queue();
  pcap_t *cd = NULL;
  if ( packet_queue == NULL ) {
    error( "Failed to create packet queue." );
    goto error;
  }

  char errbuf[ PCAP_ERRBUF_SIZE ];
  bpf_u_int32 mask = 0;
  bpf_u_int32 net = 0;
  int ret = pcap_lookupnet( interface_name, &net, &mask, errbuf );
  if ( ret < 0 ) {
    error( "Failed to get netmask for device %s ( error = %s ).", interface_name, errbuf );
    net = 0;
    mask = 0;
  }

  cd = pcap_open_live( interface_name, UINT16_MAX, 1, 100, errbuf );
  if ( cd == NULL ) {
    error( "Failed to open network interface ( interface_name = %s, error = %s ).",
           interface_name, errbuf );
    goto error;
  }

  if ( filter_expression != NULL ) {
    struct bpf_program fp;
    ret = pcap_compile( cd, &fp, filter_expression, 0, net );
    if ( ret < 0 ) {
      error( "Failed to parse filter `%s' ( error = %s ).", filter_expression, pcap_geterr( cd ) );
      goto error;
    }
    ret = pcap_setfilter( cd, &fp );
    if ( ret < 0 ) {
      error( "Failed to set filter `%s' ( error = %s ).", filter_expression, pcap_geterr( cd ) );
      goto error;
    }
  }

  int dlt = pcap_datalink( cd );

  pcap_loop( cd, -1, handle_packet, ( u_char * ) &dlt );

error:
  if ( cd != NULL ) {
    pcap_close( cd );
  }
  if ( packet_queue != NULL ) {
    delete_queue( packet_queue );
  }

  return NULL;
}
コード例 #7
0
TEST(PRIORITY_QUEUE,DELETE_QUEUE){
	
	//try to delete a queue with a forged ticket
	RESULT r = delete_queue(23131323);
	EXPECT_EQ(r.code, TICKET_INVALID);
	
	WELCOME_PACKET w = create_queue();
	EXPECT_EQ(w.result.code, SUCCESS);
	
	//delete a queue with a valid ticket
	r = delete_queue(w.ticket);
	EXPECT_EQ(r.code, SUCCESS);
	
	//try to delete an already deleted queue
	r = delete_queue(w.ticket);
	EXPECT_EQ(r.code, TICKET_INVALID);
	
}
コード例 #8
0
int main()
{

	Dnode *ptr = Create_list();
	Dnode *rear = ptr->next;
	
	printf("Please input 1 to enqueue or 2 to dequeue or 0 to end program : ");

	int in;
	while(scanf("%d",&in)!=EOF)
	{
		int input;
			if(in==1)
			{

				printf("Please input a number to enqueue : ");
				scanf("%d",&input);

				enqueue(ptr,input);
				
			}
			else if(in==2)
			{
				dequeue(rear);
			}
			else if(in==0)
				break;
			Dnode *zz;
			zz = ptr->next;

			int con = 0;

			while(zz!=rear)
			{
				con = 1;
				printf("%d ",zz->number);
				zz = zz->next;
			}
			if(con==0)
				printf("NULL");

		printf("\nPlease input 1 to enqueue or 2 to dequeue or 0 to end program : ");
	}

	delete_queue(ptr);							//Delete queue before the end of program.
	int det = determine_free();
	if(det)
		printf("All the memory are under control and eventually free back to the system\n");
	else
		printf("The memory leak has happened!\n");



	return 0;
}
コード例 #9
0
TEST(PRIORITY_QUEUE,CREATE_QUEUE){
	
	WELCOME_PACKET w = create_queue();
	delete_queue(w.ticket);
	WELCOME_PACKET wp[1024];
	
	//this is used to stress test the creation and deletion of queues.
	for(int m = 0; m < 1000; m++){

		for(int j = 0; j < 100; j++){
			
			for(int i = 0; i < MAXIMUM_NUMBER_OF_QUEUES ; i++){
				wp[i] = create_queue();
				EXPECT_EQ(wp[i].result.code, SUCCESS);
			}
			
			for(int i = 0; i < MAXIMUM_NUMBER_OF_QUEUES ; i++)
				EXPECT_EQ(delete_queue(wp[i].ticket).code, SUCCESS);
		}	
		
		for(int i = 0; i < MAXIMUM_NUMBER_OF_QUEUES ; i++)
			EXPECT_EQ(delete_queue(wp[i].ticket).code,TICKET_INVALID);
	}//end creation stress test
		
	//create a full set of queues
	for(int i = 0; i < MAXIMUM_NUMBER_OF_QUEUES ; i++){
		wp[i] = create_queue();
		EXPECT_EQ(wp[i].result.code, SUCCESS);
	}
	
	//delete some random queues and try to recreate them
	delete_queue(wp[0].ticket);
	delete_queue(wp[1023].ticket);
	delete_queue(wp[64].ticket);
	delete_queue(wp[800].ticket);
	
	wp[0] = create_queue();
	EXPECT_EQ(wp[0].result.code,SUCCESS);
	
	wp[1023] = create_queue();
	EXPECT_EQ(wp[1023].result.code,SUCCESS);
	
	wp[64] = create_queue();
	EXPECT_EQ(wp[64].result.code,SUCCESS);
	
	wp[800] = create_queue();
	EXPECT_EQ(wp[800].result.code,SUCCESS);
	
	//delete all created queues
	for(int i = 0; i < MAXIMUM_NUMBER_OF_QUEUES ; i++)
		delete_queue(wp[i].ticket);
}
コード例 #10
0
ファイル: TestJNI.cpp プロジェクト: jimifm/androidApp
JNIEXPORT void JNICALL Java_com_yichou_test_jni_MainActivity_exit(JNIEnv * env, jobject self)
{
	char *msg;

	timerStop();
	pthread_join(pid, (void **)&msg);
	LOGD("pthread_join finish, msg=%s", msg);
	delete_queue(mQueue);

	mHandler->exit();
}
コード例 #11
0
ファイル: pcap_queue.c プロジェクト: Epictetus/trema
bool
delete_pcap_queue( void ) {
  assert( packet_queue != NULL );

  bool ret = delete_queue( packet_queue );
  if ( !ret ) {
    return false;
  }

  return true;
}
コード例 #12
0
void
email_asciifile_tail( FILE* output, const char* file, int lines )
{
	FILE	*input;
	int		ch, last_ch;
	long	loc;
	int		first_line = TRUE;
	TAIL_QUEUE	queue, *q = &queue;

	if( !file ) {
		return;
	}		

	if( (input=safe_fopen_wrapper_follow(file,"r",0644)) == NULL ) {
	    // try the .old file in the off shoot case we hit this during the transition.
	    std::string szTmp = file;
	    szTmp += ".old"; 
	    
	    if( (input=safe_fopen_wrapper_follow(szTmp.c_str(),"r",0644)) == NULL ) {
		dprintf( D_FULLDEBUG, "Failed to email %s: cannot open file\n", file );
		return;
	    }
	}

	init_queue( q, lines );
	last_ch = '\n';

	while( (ch=getc(input)) != EOF ) {
		if( last_ch == '\n' && ch != '\n' ) {
			insert_queue( q, ftell(input) - 1 );
		}
		last_ch = ch;
	}

	while( !empty_queue( q ) ) {
		loc = delete_queue( q );
		/* If this is the first line, print header */
		if ( first_line ) {
			first_line = FALSE;
			fprintf(output,"\n*** Last %d line(s) of file %s:\n",
				lines, file);
		}
		/* Now print the line */
		display_line( loc, input, output );
	}
	(void)fclose( input );

	/* if we printed any of the file, print a footer */
	if ( first_line == FALSE ) {
		fprintf(output,"*** End of file %s\n\n", condor_basename(file));
	}
}
コード例 #13
0
ファイル: http_client.c プロジェクト: deadcafe/trash
bool
finalize_http_client() {
  debug( "Finalizaing HTTP client ( transactions = %p ).", transactions );

  assert( transactions != NULL );

  if ( http_client_thread != NULL ) {
    pthread_cancel( *http_client_thread );
    xfree( http_client_thread );
    http_client_thread = NULL;
  }

  if ( http_client_efd >= 0 ) {
    set_writable( http_client_efd, false );
    delete_fd_handler( http_client_efd );
    close( http_client_efd );
    http_client_efd = -1;
  }
  http_client_notify_count = 0;

  if ( main_efd >= 0 ) {
    set_readable( main_efd, false );
    delete_fd_handler( main_efd );
    close( main_efd );
    main_efd = -1;
  }

  delete_queue( main_to_http_client_queue );
  main_to_http_client_queue = NULL;
  delete_queue( http_client_to_main_queue );
  http_client_to_main_queue = NULL;

  delete_http_transaction_db();

  debug( "Finalization completed." );

  return true;
}
コード例 #14
0
int myrg_close(MYRG_INFO *info)
{
  int error=0,new_error;
  MYRG_TABLE *file;
  DBUG_ENTER("myrg_close");

  /*
    Assume that info->children_attached means that this is called from
    direct use of MERGE, not from a MySQL server. In this case the
    children must be closed and info->rec_per_key_part is part of the
    'info' multi_alloc.
    If info->children_attached is false, this is called from a MySQL
    server. Children are closed independently but info->rec_per_key_part
    must be freed.
    Just in case of a server panic (myrg_panic()) info->children_attached
    might be true. We would close the children though they should be
    closed independently and info->rec_per_key_part is not freed.
    This should be acceptable for a panic.
    In case of a MySQL server and no children, children_attached is
    always true. In this case no rec_per_key_part has been allocated.
    So it is correct to use the branch where an empty list of tables is
    (not) closed.
  */
  if (info->children_attached)
  {
    for (file= info->open_tables; file != info->end_table; file++)
    {
      /* purecov: begin inspected */
      if ((new_error= mi_close(file->table)))
        error= new_error;
      else
        file->table= NULL;
      /* purecov: end */
    }
  }
  else
    my_free((uchar*) info->rec_per_key_part, MYF(MY_ALLOW_ZERO_PTR));
  delete_queue(&info->by_key);
  pthread_mutex_lock(&THR_LOCK_open);
  myrg_open_list=list_delete(myrg_open_list,&info->open_list);
  pthread_mutex_unlock(&THR_LOCK_open);
  VOID(pthread_mutex_destroy(&info->mutex));
  my_free((uchar*) info,MYF(0));
  if (error)
  {
    DBUG_RETURN(my_errno=error);
  }
  DBUG_RETURN(0);
}
コード例 #15
0
main()
{
    int i, j = 0, k;
    int topsort[ MAX ], indeg[ MAX ];

    create_graph();
    printf( "The adjacency matrix is :\n" );
    display();
    /*Find the indegree of each node*/

    for ( i = 1;i <= n;i++ )
        {
            indeg[ i ] = indegree( i );

            if ( indeg[ i ] == 0 )
                insert_queue( i );
        }

    while ( front <= rear )  /*Loop till queue is not empty */
        {
            k = delete_queue();
            topsort[ j++ ] = k; /*Add node k to topsort array*/
            /*Delete all edges going fron node k */

            for ( i = 1;i <= n;i++ )
                {
                    if ( adj[ k ][ i ] == 1 )
                        {
                            adj[ k ][ i ] = 0;
                            indeg[ i ] = indeg[ i ] – 1;

                            if ( indeg[ i ] == 0 )
                                insert_queue( i );
                        }
                } /*End of for*/
        } /*End of while*/

    printf( "Nodes after topological sorting are :\n" );

    for ( i = 0;i < j;i++ )
        printf( "%d ", topsort[ i ] );

    printf( "\n" );
} /*End of main()*/
コード例 #16
0
main()
{
	int i,v,count,topo_order[MAX],indeg[MAX];
	
	create_graph();
	
	/*Find the indegree of each vertex*/
	for(i=0;i<n;i++)
	{
		indeg[i] = indegree(i);
		if( indeg[i] == 0 )
			insert_queue(i);
	}
	
	count = 0;

	while(  !isEmpty_queue( ) && count < n )
	{
		v = delete_queue();
    	topo_order[++count] = v; /*Add vertex v to topo_order array*/
		/*Delete all edges going fron vertex v */
		for(i=0; i<n; i++)
		{
			if(adj[v][i] == 1)
			{
				adj[v][i] = 0;
				indeg[i] = indeg[i]-1;
				if(indeg[i] == 0)
					insert_queue(i);
			}
		}
	}
	
	if( count < n )
	{
		printf("No topological ordering possible, graph contains cycle\n");
		exit(1);
	}
	printf("Vertices in topological order are :\n");
	for(i=1; i<=count; i++)
		printf( "%d ",topo_order[i] );
	printf("\n");
}/*End of main()*/
コード例 #17
0
ファイル: main.c プロジェクト: kori4r2/trabalho6
int main(int argc, char *argv[]){

	TABLE *table = create_table();
	read_table(stdin, table);
//	print_table(table);
	PIECE_LIST *list = create_piece_list(table);
	QUEUE *queue = create_queue();
	list_moves(table, queue, list);
	print_queue(queue);
//printf("-----------------------------------------------------\n");
//	print_table(table);

	delete_queue(&queue);
	delete_list(&list);
//printf("-----------------------------------------------------\n");
//	print_table(table);
	delete_table(&table);

	return 0;
}
コード例 #18
0
void BFS(int v)
{
		int i;
		insert_queue(v);
		state[v]=waiting;
		while(!isempty_queue())
		{
				v=delete_queue();
				printf("%d  ",v);
				state[v]=visited;
				for(i=0;i<n;i++)
				{
						if(adj[v][i]==1&&state[i]==initial)
						{	
								insert_queue(i);
								state[i]=waiting;
						}
				}
		}
		printf("\n");
}
コード例 #19
0
TEST(PRIORITY_QUEUE,DEQUEUE){
    ELEMENT_RESULT ele_result = dequeue(424234);
	EXPECT_EQ(ele_result.result.code,TICKET_INVALID);//or does not exist
	EXPECT_EQ(strcmp(ele_result.element.item,""),0);
	EXPECT_EQ(ele_result.element.priority,0);
	
	
	WELCOME_PACKET packet = create_queue();
	ele_result = dequeue(packet.ticket);
	EXPECT_EQ(ele_result.result.code,QUEUE_IS_EMPTY);
	
	ELEMENT e;
	char temp[MAX_STRING_LENGTH];
	
	for(int i = 0; i < MAXIMUM_NUMBER_OF_ELEMENTS_IN_A_QUEUE; i++){
		snprintf(temp,MAX_STRING_LENGTH,"%d",i);
		e = fill_element(temp,4);
		enqueue(e,packet.ticket);
	}
	
	for(int i = 0; i < MAXIMUM_NUMBER_OF_ELEMENTS_IN_A_QUEUE; i++){
		ELEMENT_RESULT item = dequeue(packet.ticket);
		e = item.element;
		snprintf(temp,MAX_STRING_LENGTH,"%d",i);
		EXPECT_EQ(strcmp(e.item,temp),0);
	}
	
	ELEMENT_RESULT r = dequeue(packet.ticket);
	EXPECT_EQ(r.result.code,QUEUE_IS_EMPTY);
	
	RESULT res = delete_queue(packet.ticket);
	EXPECT_EQ(res.code,SUCCESS);
	
	ELEMENT_RESULT result = dequeue(packet.ticket);
	EXPECT_EQ(r.result.code,QUEUE_IS_EMPTY);
}
コード例 #20
0
ファイル: conventional.c プロジェクト: acekiller/MasterThesis
void 
carmen_conventional_dynamic_program(int goal_x, int goal_y) 
{
  double *utility_ptr;
  int index;
  double max_val, min_val;
  int num_expanded;
  int done;

  struct timeval start_time, end_time;
  int delta_sec, delta_usec;
  static double last_time, cur_time, last_print;
  
  queue state_queue;
  state_ptr current_state;

  if (costs == NULL)
    return;

  gettimeofday(&start_time, NULL);

  cur_time = carmen_get_time();
  if ((int)(cur_time - last_print) > 10) {
    carmen_verbose("Time since last DP: %d secs, %d usecs\n", (int)(cur_time - last_time),
		   ((int)((cur_time-last_time)*1e6)) % 1000000);
    last_print = cur_time;
  }
  last_time = cur_time;

  if (utility == NULL) {
    utility = (double *)calloc(x_size*y_size, sizeof(double));
    carmen_test_alloc(utility);
  }
  
  utility_ptr = utility;
  for (index = 0; index < x_size * y_size; index++) 
    *(utility_ptr++) = -1;

  if (is_out_of_map(goal_x, goal_y))
    return;

  max_val = -MAXDOUBLE;
  min_val = MAXDOUBLE; 
  done = 0;

  state_queue = make_queue();

  current_state = carmen_conventional_create_state(goal_x, goal_y, 0);
  max_val = MAX_UTILITY;
  *(utility_value(goal_x, goal_y)) = max_val;
  add_neighbours_to_queue(goal_x, goal_y, state_queue);    
  num_expanded = 1;
  
  while ((current_state = pop_queue(state_queue)) != NULL) {
    num_expanded++;
    if (current_state->cost <= *(utility_value(current_state->x, current_state->y)))
      add_neighbours_to_queue(current_state->x, current_state->y, state_queue);
    if (current_state->cost < min_val)
      min_val = current_state->cost;
    free(current_state);
  }

  delete_queue(&state_queue);

  gettimeofday(&end_time, NULL);

  delta_usec = end_time.tv_usec - start_time.tv_usec;
  delta_sec = end_time.tv_sec - start_time.tv_sec;
  if (delta_usec < 0) {
    delta_sec--;
    delta_usec += 1000000;
  }

  //  carmen_warn("Elasped time for dp: %d secs, %d usecs\n", delta_sec, delta_usec);
}
コード例 #21
0
main()
{
	int i,v;
	int topo_order[MAX],indeg[MAX];
	int count;

	int j;

	create_graph();
	
	/*Find the indegree of each vertex*/
	for(i=0; i<n; i++)
	{
		indeg[i] = indegree(i);
		if( indeg[i] == 0 )
			insert_queue(i);
	}
	
	for(j=0; j<n; j++)
		printf("In(%d) = %d\t",j, indeg[j]);
	printf("\n");
	display_queue();	

	count = 0;
	while( !isEmpty_queue() && count<n )
	{
		v = delete_queue();
        printf("Delete %d and edges going from it\n",v);
		topo_order[++count] = v; /*Add vertex v to topo_order array*/
		/*Delete all edges going fron vertex v */
		for(i=0; i<n; i++)
		{
			if(adj[v][i]==1)
			{
				adj[v][i] = 0;
				indeg[i] = indeg[i]-1;
				if(indeg[i] == 0)
				{
					printf("Now vertex %d has zero indegree so insert it in the queue\n",i);
					insert_queue(i);
				}
			}
		}
		for(j=0; j<n; j++)
		{
			if(indeg[j]!=0)
				printf("In(%d) = %d\t",j, indeg[j]);
		}
		printf("\n");
		display_queue();
		STOP;
	}

	printf("count = %d\n",count);	
	if( count < n )
	{
		printf("No topological ordering possible, graph contains cycle\n");
		exit(1);
	}
	printf("Vertices in topological order are :\n");
	for(i=1; i<=count; i++)
		printf( "%d ",topo_order[i] );
	printf("\n");
}/*End of main()*/
コード例 #22
0
static void search(carmen_roadmap_vertex_t *start_node, 
		   carmen_roadmap_t *roadmap)
{
  int num_expanded;
  state_ptr current_state;
  int i, j;
  double *fwd_utilities, *open_list;
  int *parent_ptrs;
  carmen_roadmap_vertex_t *node_list;
  carmen_roadmap_edge_t *edges;
  double min_neighbour_utility;
  int min_neighbour, neighbour_id;
  int min_edge;
  double best_utility, utility;
  int best_neighbour;
  queue the_state_queue = NULL;

  the_state_queue = make_queue();

  node_list = (carmen_roadmap_vertex_t *)(roadmap->nodes->list);

  fwd_utilities = (double *)calloc(roadmap->nodes->length, sizeof(double));
  carmen_test_alloc(fwd_utilities);
  for (i = 0; i < roadmap->nodes->length; i++)
    fwd_utilities[i] = FLT_MAX;

  open_list = (double *)calloc(roadmap->nodes->length, sizeof(double));
  carmen_test_alloc(open_list);
  for (i = 0; i < roadmap->nodes->length; i++)
    open_list[i] = -1;

  parent_ptrs = (int *)calloc(roadmap->nodes->length, sizeof(int));
  carmen_test_alloc(parent_ptrs);
  for (i = 0; i < roadmap->nodes->length; i++)
    parent_ptrs[i] = -1;

  push_state(start_node->id, start_node->id, 0, 0, the_state_queue);
  fwd_utilities[start_node->id] = 0;

  node_list[roadmap->goal_id].utility = 0;
  num_expanded = 0;

  while ((current_state = pop_queue(the_state_queue)) != NULL) {
    num_expanded++;
    if (0)
    carmen_warn("Popped %d\n", current_state->id);
    fwd_utilities[current_state->id] = 
      fwd_utilities[current_state->parent_id] + current_state->cost;
    parent_ptrs[current_state->id] = current_state->parent_id;
    open_list[current_state->id] = -2;
    assert (fwd_utilities[current_state->id] < 1e5);
    if (current_state->id == roadmap->goal_id) {
      if (node_list[roadmap->goal_id].edges->length == 0)
	construct_edges(roadmap, roadmap->goal_id);
      empty_queue(the_state_queue);
    } else {
      add_neighbours_to_queue(roadmap, current_state->id,
			      roadmap->goal_id, fwd_utilities, open_list,
			      the_state_queue);
    }

    free(current_state);
  }

  carmen_warn("Num Expanded %d\n", num_expanded);

  if (fwd_utilities[roadmap->goal_id] > FLT_MAX/2)
    carmen_warn("PROBLEM\n");
  else if (0) {
    node_list[roadmap->goal_id].utility = 0;
    i = roadmap->goal_id;
    while (i != start_node->id) {
      edges = (carmen_roadmap_edge_t *)(node_list[i].edges->list);
      assert (node_list[i].edges->length > 0);
      min_neighbour_utility = FLT_MAX;      
      min_neighbour = -1;
      min_edge = -1;
      for (j = 0; j < node_list[i].edges->length; j++) {
	if (edges[j].cost > 1e5 || edges[j].blocked)
	  continue;
	neighbour_id = edges[j].id;
	assert (fwd_utilities[neighbour_id] >= 0);
	if (fwd_utilities[neighbour_id] < min_neighbour_utility) {
	  min_neighbour_utility = fwd_utilities[neighbour_id];
	  min_neighbour = neighbour_id;
	  min_edge = j;
	}
      }
      assert (min_neighbour >= 0);
      assert (min_neighbour_utility < fwd_utilities[i]);
      assert(node_list[min_neighbour].utility > FLT_MAX/2 ||
	     node_list[min_neighbour].utility ==
	     node_list[i].utility + edges[min_edge].cost);      

      if (node_list[min_neighbour].utility > FLT_MAX/2) {
	node_list[min_neighbour].utility = node_list[i].utility + 
	  edges[min_edge].cost;

	assert(node_list[i].utility < FLT_MAX/2);
	assert(fwd_utilities[i] < FLT_MAX/2);
	assert(fwd_utilities[min_neighbour] < FLT_MAX/2);
	assert(node_list[min_neighbour].utility < 1e5);
      }
      assert (node_list[i].utility < node_list[min_neighbour].utility);
      //      carmen_warn("%d %d %f %f\n", node_list[i].x, node_list[i].y, node_list[i].utility, FLT_MAX/2);

      i = min_neighbour;
      assert(node_list[i].utility < FLT_MAX/2);
    }
  } else {
    node_list[roadmap->goal_id].utility = 0;
    i = roadmap->goal_id;
    while (i != start_node->id) {
      min_neighbour = parent_ptrs[i];
      assert (min_neighbour >= 0);

      min_neighbour_utility = fwd_utilities[min_neighbour];
      assert (min_neighbour_utility < fwd_utilities[i]);

      edges = (carmen_roadmap_edge_t *)(node_list[i].edges->list);
      assert (node_list[i].edges->length > 0);
      for (min_edge = 0; min_edge < node_list[i].edges->length; min_edge++) {
	if (edges[min_edge].id == min_neighbour)
	  break;
      }
      assert (min_edge < node_list[i].edges->length);
      assert(node_list[min_neighbour].utility > FLT_MAX/2 ||
	     fabs(node_list[min_neighbour].utility  - 
		  (node_list[i].utility + edges[min_edge].cost)) < 1e6);      

      if (node_list[min_neighbour].utility > FLT_MAX/2) {
	carmen_roadmap_edge_t *edges2;
	edges2 = (carmen_roadmap_edge_t *)node_list[min_neighbour].edges->list;
	node_list[min_neighbour].utility = node_list[i].utility + 
	  edges[min_edge].cost;
	best_neighbour = -1;
	best_utility = FLT_MAX;
	for (j = 0; j < node_list[min_neighbour].edges->length; j++) {
	  if (edges2[j].cost > 1e5 || edges2[j].blocked)
	    continue;      
	  if (node_list[edges2[j].id].utility > FLT_MAX/2)
	    continue;
	  utility = node_list[edges2[j].id].utility;
	  if (utility < best_utility) {
	    best_utility = utility;
	    best_neighbour = edges2[j].id;
	  }
	}
	
	if (best_neighbour < 0)
	  continue;
	assert (best_utility < FLT_MAX/2);
	assert (node_list[best_neighbour].utility < 
		node_list[min_neighbour].utility);

	assert(node_list[i].utility < FLT_MAX/2);
	assert(fwd_utilities[i] < FLT_MAX/2);
	assert(fwd_utilities[min_neighbour] < FLT_MAX/2);
	assert(node_list[min_neighbour].utility < 1e5);
      }
      assert (node_list[i].utility < node_list[min_neighbour].utility);
      //      carmen_warn("%d %d %f %f\n", node_list[i].x, node_list[i].y, node_list[i].utility, FLT_MAX/2);

      i = min_neighbour;
      assert(node_list[i].utility < FLT_MAX/2);
    }
  }

  /* Check to make sure that no node is a local minimum. The only node that's
     allowed to be a local minimum is the goal.
   */
  for (i = 0; i < roadmap->nodes->length; i++) {
    if (i == roadmap->goal_id)
      continue;
    edges = (carmen_roadmap_edge_t *)(node_list[i].edges->list);

    if (node_list[i].utility > FLT_MAX/2)
      continue;

    best_neighbour = -1;
    best_utility = FLT_MAX;
    for (j = 0; j < node_list[i].edges->length; j++) {
      if (edges[j].cost > 1e5 || edges[j].blocked)
	continue;      
      if (node_list[edges[j].id].utility > FLT_MAX/2)
	continue;
      utility = node_list[edges[j].id].utility;
      if (utility < best_utility) {
	best_utility = utility;
	best_neighbour = edges[j].id;
      }
    }

    if (best_neighbour < 0)
      continue;
    assert (best_utility < FLT_MAX/2);
    assert (node_list[best_neighbour].utility < node_list[i].utility);
  }

  free(fwd_utilities);
  delete_queue(&the_state_queue);
}
コード例 #23
0
ファイル: RBT.c プロジェクト: Nesokas/sampleProject
void destroy_node(struct node *node){
	delete_queue(node->queue);
	free(node);
}
コード例 #24
0
TEST(PRIORITY_QUEUE,ENQUEUE){
	
	//try a bad ticket numbers
	ELEMENT e = {"test",9};
	
	RESULT r = enqueue(e,-313213);
	EXPECT_EQ(r.code, TICKET_INVALID);
	
	r = enqueue(e,0);
	EXPECT_EQ(r.code, TICKET_INVALID);
	
	//create a valid queue
	WELCOME_PACKET packet = create_queue();
		
	//try bad priority
	e = fill_element("test",-3);
	
	r = enqueue(e,packet.ticket);
	EXPECT_EQ(r.code, ITEM_INVALID);
	
	//try bad priority
	e = fill_element("test",11);
	
	r = enqueue(e,packet.ticket);
	EXPECT_EQ(r.code, ITEM_INVALID);
	//fill queue	
	e = fill_element("test",4);
	for(int i = 0; i < MAXIMUM_NUMBER_OF_ELEMENTS_IN_A_QUEUE; i++){
		r = enqueue(e,packet.ticket);
		EXPECT_EQ(get_size(packet.ticket).size,i+1);
		EXPECT_EQ(r.code, SUCCESS);
	}

	//add one to many to the queue
	r = enqueue(e,packet.ticket);
	EXPECT_EQ(r.code, QUEUE_IS_FULL);

	//delete the queue
	r = delete_queue(packet.ticket);
	EXPECT_EQ(r.code,SUCCESS);
	
	//try to enque on a deleted queue
	r = enqueue(e,packet.ticket);
	EXPECT_EQ(r.code, TICKET_INVALID);
	
	///////////////////////////////////////////////////////////
	// CHECK FOR THE CORRECT ENQUEUEUING BASED ON PRIORITIES //
	
	srand(time(NULL));
	
	packet = create_queue();

	// fill queue with max elements with random priorities from
	// [0-10], then compare the insertion number as the base of the
	// comparision
	char temp[1024];
	
	for(int i = 0; i < MAXIMUM_NUMBER_OF_ELEMENTS_IN_A_QUEUE; i++){
		snprintf(temp,1024,"%d",i);
		e = fill_element(temp,rand()%10);
		r = enqueue(e,packet.ticket);
		EXPECT_EQ(get_size(packet.ticket).size,i+1);
		EXPECT_EQ(r.code, SUCCESS);
	}
	
	ELEMENT_RESULT er;
	ELEMENT_RESULT last;
	
	last = dequeue(packet.ticket);
	
	for(int i = 1; i < MAXIMUM_NUMBER_OF_ELEMENTS_IN_A_QUEUE; i++){		
		er = dequeue(packet.ticket);
		EXPECT_TRUE(last.element.priority >= er.element.priority);
		
		if(last.element.priority == er.element.priority)
			EXPECT_TRUE(atoi(last.element.item) < atoi(er.element.item));
		
		last = er;
	}
	
	
}
コード例 #25
0
void mv_stop(void)
{
	free(memory);
	free(frame_of);
	delete_queue(fifo);
}
コード例 #26
0
int main() {
  const int max_entries = 5; /* size of the queue */

  /* define some variables to hold Foo structs*/
  Foo* new_foo1;
  Foo* new_foo2; 
  Foo* new_foo3;
  Foo* new_foo4;
  Foo* new_foo5;
  Foo* new_foo6;
  Foo* returned_foo;

  /* create a Queue struct with max_entries size */
  Queue *new_queue = create_queue(max_entries);

  /* show pointer addresses to demonstrate wrap around */
  printf("\nWrap around demonstration before Queue is modified:");
  printf("\nBuffer: %p\n", new_queue);
  printf("Head: %p\n", new_queue->queue_head);
  printf("Tail: %p\n\n", new_queue->queue_tail);


  /* allocate a Foo and add it onto the queue */
  new_foo1 = (Foo *) malloc(sizeof(Foo));
  new_foo1->x = 6;
  new_foo1->y = 14.79;
  printf("Adding: x = %5d, y = %10.3f\n", new_foo1->x, new_foo1->y);
  enqueue(new_queue, (void *) new_foo1);

  /* allocate a Foo and add it onto the queue */
  new_foo2 = (Foo *) malloc(sizeof(Foo));
  new_foo2->x = 217;
  new_foo2->y = 3.14159;
  printf("Adding: x = %5d, y = %10.3f\n", new_foo2->x, new_foo2->y);
  enqueue(new_queue, (void *) new_foo2);;

  /* allocate a Foo and add it onto the queue */
  new_foo3 = (Foo *) malloc(sizeof(Foo));
  new_foo3->x = 500;
  new_foo3->y = 4.50483;
  printf("Adding: x = %5d, y = %10.3f\n", new_foo3->x, new_foo3->y);
  enqueue(new_queue, (void *) new_foo3);

  /* allocate a Foo and add it onto the queue */
  new_foo4 = (Foo *) malloc(sizeof(Foo));
  new_foo4->x = 4059;
  new_foo4->y = 22.48300;
  printf("Adding: x = %5d, y = %10.3f\n", new_foo4->x, new_foo4->y);
  enqueue(new_queue, (void *) new_foo4);

  /* allocate a Foo and add it onto the queue */
  new_foo5 = (Foo *) malloc(sizeof(Foo));
  new_foo5->x = 1010;
  new_foo5->y = 1056.3827;
  printf("Adding: x = %5d, y = %10.3f\n", new_foo5->x, new_foo5->y);
  enqueue(new_queue, (void *) new_foo5);

  /* show pointer addresses to demonstrate wrap around */
  printf("\nWrap around demonstration after max entries are added:");
  printf("\nBuffer: %p\n", new_queue);
  printf("Head: %p\n", new_queue->queue_head);
  printf("Tail: %p\n\n", new_queue->queue_tail);
  
  /* attempt to add more than max number of entries onto the queue */
  new_foo6 = (Foo *) malloc(sizeof(Foo));
  new_foo6->x = 666;
  new_foo6->y = 66.666666;
  printf("Attempting to add more than max # of entries to the queue.\n");
  printf("Last entry is not added to queue!\n");
  printf("Adding: x = %5d, y = %10.3f\n", new_foo6->x, new_foo6->y);
  enqueue(new_queue, (void *) new_foo6);

  /* remove entries from the queue and print them */
  returned_foo = (Foo *) dequeue(new_queue);
  printf("Removed:  x = %5d, y = %10.3f\n", returned_foo->x, returned_foo->y);
  returned_foo = (Foo *) dequeue(new_queue);
  printf("Removed:  x = %5d, y = %10.3f\n", returned_foo->x, returned_foo->y);
  returned_foo = (Foo *) dequeue(new_queue);
  printf("Removed:  x = %5d, y = %10.3f\n", returned_foo->x, returned_foo->y);
  returned_foo = (Foo *) dequeue(new_queue);
  printf("Removed:  x = %5d, y = %10.3f\n", returned_foo->x, returned_foo->y);
  returned_foo = (Foo *) dequeue(new_queue);
  printf("Removed:  x = %5d, y = %10.3f\n", returned_foo->x, returned_foo->y);

  /* show pointer addresses to demonstrate wrap around */
  printf("\nWrap around demonstration after entries are removed:");
  printf("\nBuffer: %p\n", new_queue);
  printf("Head: %p\n", new_queue->queue_head);
  printf("Tail: %p\n\n", new_queue->queue_tail);

  /* attempt to remove non-existant element from queue */
  returned_foo = (Foo *) dequeue(new_queue);
  /* check for removing  more elements than exist in the queue */
  if(returned_foo != NULL) {
    printf("Removed:  x = %5d, y = %10.3f\n", returned_foo->x, returned_foo->y);
  } else {
    printf("\nError. Trying to remove nonexistant entry from queue!\n");
  } /* end else */
  

  /* free any allocated memory and clean up */
  delete_queue(new_queue);
  free(new_foo1);
  free(new_foo2);
  free(new_foo3);
  free(new_foo4);
  free(new_foo5);
  free(new_foo6);

  return 0; /* success */
} /* end function main */