Exemplo n.º 1
0
static void DeleteList()//START PROBLEM 3
{
	int boolean = 1;
	int content;
	struct node *head = NULL;

	while(boolean)
	{
		if(yesno("Would you like to enter a value (Y/N)?"))
		{
			read_int("Please enter your value: ", &content);
			AppendNode(&head, content);
		}
		else
		{
			boolean = 0;
		}
	}

	//Now delete the list
	if(yesno("Would you like to delete the list (Y/N)?"))
	{
		Delete_List(&head);
	}
	if(head == NULL)
	{
		printf("The head node has been set to NULL.\n");
	}
}//END PROBLEM 3
Exemplo n.º 2
0
void Reallocate_Neighbor_List( reax_list *far_nbrs, int n, int num_intrs,
			       MPI_Comm comm )
{
  Delete_List( far_nbrs, comm );
  if(!Make_List( n, num_intrs, TYP_FAR_NEIGHBOR, far_nbrs, comm )){
    fprintf(stderr, "Problem in initializing far nbrs list. Terminating!\n");
    MPI_Abort( comm, INSUFFICIENT_MEMORY );
  }
}
Exemplo n.º 3
0
int main() {
	int array[LINK_LENGTH] = { 1, 3, 4, 2, 9, 6, 7, 5, 0, 8 };
	LinkList L;
	int i = 0;
	NODE *node;

	printf("Array is: ");
	while (i < LINK_LENGTH) {
		printf("%d ", array[i]);
		i++;
	}
	printf("\n");

	//0. create
	printf("Create_List\n");
	L = Create_List(array);
	Print_List(L);

	//1. find
	printf("\n");
	printf("Find_List\n");
	Print_List(L);
	node = Find_List(L, 3);
	Print_NODE(node);

	//2. update
	printf("\n");
	Print_List(L);
	printf("Update_List\n");
	Update_List(L, 3, 23);
	Print_List(L);

	//3. insert
	printf("\n");
	Print_List(L);
	printf("Insert_List\n");
	Insert_List(L, 3, 99);
	Print_List(L);

	//4. delete
	printf("\n");
	Print_List(L);
	printf("Delete_List\n");
	Delete_List(L, 8);
	Print_List(L);

	//5. free
	printf("\n");
	Print_List(L);
	printf("Free resource!\n");
	Free_List(L);
	Print_List(L);
	return 0;
}
void								
BF_GUI_FtpPanel_DeleteTask::Run()
{
	iOperIndex  = 0;
	iOperCount = loNode.CountAll(true);	
	SetProgress(iOperIndex,iOperCount);
	Delete_List(&loNode);	
	
	// reload panel_nodes 
	BMessenger 	oMessenger(poPanel);
	BMessage	oMessage(BF_FTP_MSG_DIR_RELOAD_START);
	oMessenger.SendMessage(&oMessage);
}
Exemplo n.º 5
0
int Reallocate_Bonds_List( reax_system *system, reax_list *bonds,
			   int *total_bonds, int *est_3body, MPI_Comm comm )
{
  int i;

  *total_bonds = 0;
  *est_3body = 0;
  for( i = 0; i < system->N; ++i ){
    *est_3body += SQR(system->my_atoms[i].num_bonds);
    // commented out - already updated in validate_lists in forces.c
    // system->my_atoms[i].num_bonds = MAX( Num_Entries(i,bonds)*2, MIN_BONDS );
    *total_bonds += system->my_atoms[i].num_bonds;
  }
  *total_bonds = (int)(MAX( *total_bonds * SAFE_ZONE, MIN_CAP*MIN_BONDS ));
  
  Delete_List( bonds, comm );
  if(!Make_List(system->total_cap, *total_bonds, TYP_BOND, bonds, comm)) {
    fprintf( stderr, "not enough space for bonds list. terminating!\n" );
    MPI_Abort( comm, INSUFFICIENT_MEMORY );
  }

  return SUCCESS;
}
Exemplo n.º 6
0
int Reallocate_HBonds_List( reax_system *system, reax_list *hbonds, 
			    MPI_Comm comm )
{
  int i, id, total_hbonds;

  total_hbonds = 0;
  for( i = 0; i < system->n; ++i )
    if( (id = system->my_atoms[i].Hindex) >= 0 ) {
      // commented out - already updated in validate_lists in forces.c
      // system->my_atoms[i].num_hbonds = MAX(Num_Entries(id,hbonds)*SAFER_ZONE,
      //                                   MIN_HBONDS);
      total_hbonds += system->my_atoms[i].num_hbonds;
    } 
  total_hbonds = (int)(MAX( total_hbonds*SAFER_ZONE, MIN_CAP*MIN_HBONDS ));
  
  Delete_List( hbonds, comm );
  if( !Make_List( system->Hcap, total_hbonds, TYP_HBOND, hbonds, comm ) ) {
    fprintf( stderr, "not enough space for hbonds list. terminating!\n" );
    MPI_Abort( comm, INSUFFICIENT_MEMORY );
  }

  return total_hbonds;
}
Exemplo n.º 7
0
void ReAllocate( reax_system *system, control_params *control, 
		 simulation_data *data, storage *workspace, reax_list **lists, 
		 mpi_datatypes *mpi_data )
{
  int i, j, k, p;
  int num_bonds, est_3body, nflag, Nflag, Hflag, mpi_flag, ret, total_send;
  int renbr, newsize;
  reallocate_data *realloc;
  reax_list *far_nbrs;
  sparse_matrix *H;
  grid *g;
  neighbor_proc *nbr_pr;
  mpi_out_data *nbr_data;
  MPI_Comm comm;
  char msg[200];

  realloc = &(workspace->realloc);
  g = &(system->my_grid);
  comm = mpi_data->world;

#if defined(DEBUG)
  fprintf( stderr, "p%d@reallocate: n: %d, N: %d, numH: %d\n",
	   system->my_rank, system->n, system->N, system->numH );
  fprintf( stderr, "p%d@reallocate: local_cap: %d, total_cap: %d, Hcap: %d\n",
	   system->my_rank, system->local_cap, system->total_cap, 
	   system->Hcap);
  fprintf( stderr, "p%d: realloc.num_far: %d\n", 
	   system->my_rank, realloc->num_far );
  fprintf( stderr, "p%d: realloc.H: %d, realloc.Htop: %d\n", 
	   system->my_rank, realloc->H, realloc->Htop );
  fprintf( stderr, "p%d: realloc.Hbonds: %d, realloc.num_hbonds: %d\n", 
	   system->my_rank, realloc->hbonds, realloc->num_hbonds );
  fprintf( stderr, "p%d: realloc.bonds: %d, num_bonds: %d\n", 
	   system->my_rank, realloc->bonds, realloc->num_bonds );
  fprintf( stderr, "p%d: realloc.num_3body: %d\n", 
	   system->my_rank, realloc->num_3body );
#endif
  
  // IMPORTANT: LOOSE ZONES CHECKS ARE DISABLED FOR NOW BY &&'ing with 0!!!
  nflag = 0;
  if( system->n >= DANGER_ZONE * system->local_cap ||
      (0 && system->n <= LOOSE_ZONE * system->local_cap) ) {
    nflag = 1;
    system->local_cap = MAX( (int)(system->n * SAFE_ZONE), MIN_CAP );
  }

  Nflag = 0;
  if( system->N >= DANGER_ZONE * system->total_cap ||
      (0 && system->N <= LOOSE_ZONE * system->total_cap) ) {
    Nflag = 1;
    system->total_cap = MAX( (int)(system->N * SAFE_ZONE), MIN_CAP );
  }

  if( Nflag ) {
    /* system */
#if defined(DEBUG_FOCUS)
    fprintf( stderr, "p%d: reallocating system and workspace -"\
	     "n=%d  N=%d  local_cap=%d  total_cap=%d\n",
	     system->my_rank, system->n, system->N, 
	     system->local_cap, system->total_cap );
#endif
    ret = Allocate_System( system, system->local_cap, system->total_cap, msg );
    if( ret != SUCCESS ) {
      fprintf( stderr, "not enough space for atom_list: total_cap=%d",
	       system->total_cap );
      fprintf( stderr, "terminating...\n" );
      MPI_Abort( comm, INSUFFICIENT_MEMORY );
    }
    
    /* workspace */
    DeAllocate_Workspace( control, workspace );
    ret = Allocate_Workspace( system, control, workspace, system->local_cap, 
			      system->total_cap, comm, msg );
    if( ret != SUCCESS ) {
      fprintf( stderr, "no space for workspace: local_cap=%d total_cap=%d",
	       system->local_cap, system->total_cap );
      fprintf( stderr, "terminating...\n" );
      MPI_Abort( comm, INSUFFICIENT_MEMORY );
    }
  }


  renbr = (data->step - data->prev_steps) % control->reneighbor == 0;
  /* far neighbors */
  if( renbr ) {
    far_nbrs = *lists + FAR_NBRS;

    if( Nflag || realloc->num_far >= far_nbrs->num_intrs * DANGER_ZONE ) {
      if( realloc->num_far > far_nbrs->num_intrs ) {
	fprintf( stderr, "step%d-ran out of space on far_nbrs: top=%d, max=%d",
		 data->step, realloc->num_far, far_nbrs->num_intrs );
	MPI_Abort( comm, INSUFFICIENT_MEMORY );
      }

      newsize = static_cast<int> 
	(MAX( realloc->num_far*SAFE_ZONE, MIN_CAP*MIN_NBRS ));      
#if defined(DEBUG_FOCUS)
      fprintf( stderr, "p%d: reallocating far_nbrs: num_fars=%d, space=%dMB\n", 
	       system->my_rank, (int)(realloc->num_far*SAFE_ZONE), 
	       (newsize*sizeof(far_neighbor_data)/(1024*1024)) );
#endif
      
      Reallocate_Neighbor_List( far_nbrs, system->total_cap, newsize, comm );
      realloc->num_far = 0;
    }
  }

#if defined(PURE_REAX)
  /* qeq coef matrix */
  H = workspace->H;
  if( nflag || realloc->Htop >= H->m * DANGER_ZONE ) {
    if( realloc->Htop > H->m ) {
      fprintf( stderr, 
	       "step%d - ran out of space on H matrix: Htop=%d, max = %d",
	       data->step, realloc->Htop, H->m );
      MPI_Abort( comm, INSUFFICIENT_MEMORY );
    }
#if defined(DEBUG_FOCUS)
    fprintf( stderr, "p%d: reallocating H matrix: Htop=%d, space=%dMB\n", 
	     system->my_rank, (int)(realloc->Htop*SAFE_ZONE), 
	     (int)(realloc->Htop * SAFE_ZONE * sizeof(sparse_matrix_entry) / 
		   (1024*1024)) );
#endif

    newsize = static_cast<int> 
	(MAX( realloc->Htop*SAFE_ZONE, MIN_CAP*MIN_NBRS ));
    Reallocate_Matrix( &(workspace->H), system->local_cap, 
		       newsize, "H", comm );
    //Deallocate_Matrix( workspace->L );
    //Deallocate_Matrix( workspace->U );
    workspace->L = NULL;
    workspace->U = NULL;
    realloc->Htop = 0;
  }
#endif /*PURE_REAX*/

  /* hydrogen bonds list */
  if( control->hbond_cut > 0 ) { 
    Hflag = 0;
    if( system->numH >= DANGER_ZONE * system->Hcap || 
	(0 && system->numH <= LOOSE_ZONE * system->Hcap) ) {
      Hflag = 1;
      system->Hcap = MAX( system->numH * SAFER_ZONE, MIN_CAP );
    }

    if( Hflag || realloc->hbonds ) {
      ret = Reallocate_HBonds_List( system, (*lists)+HBONDS, comm );
      realloc->hbonds = 0;
#if defined(DEBUG_FOCUS)
      fprintf(stderr, "p%d: reallocating hbonds: total_hbonds=%d space=%dMB\n",
	      system->my_rank, ret, (int)(ret*sizeof(hbond_data)/(1024*1024)));
#endif
    }
  }

  /* bonds list */
  num_bonds = est_3body = -1;
  if( Nflag || realloc->bonds ){
    Reallocate_Bonds_List( system, (*lists)+BONDS, &num_bonds, 
			   &est_3body, comm );
    realloc->bonds = 0;
    realloc->num_3body = MAX( realloc->num_3body, est_3body );
#if defined(DEBUG_FOCUS)
    fprintf( stderr, "p%d: reallocating bonds: total_bonds=%d, space=%dMB\n", 
	     system->my_rank, num_bonds, 
	     (int)(num_bonds*sizeof(bond_data)/(1024*1024)) );
#endif
  }

  /* 3-body list */
  if( realloc->num_3body > 0 ) {
#if defined(DEBUG_FOCUS)
    fprintf( stderr, "p%d: reallocating 3body list: num_3body=%d, space=%dMB\n",
	     system->my_rank, realloc->num_3body, 
	     (int)(realloc->num_3body * sizeof(three_body_interaction_data) / 
		   (1024*1024)) );
#endif
    Delete_List( (*lists)+THREE_BODIES, comm );
    
    if( num_bonds == -1 )
      num_bonds = ((*lists)+BONDS)->num_intrs;

    realloc->num_3body = (int)(MAX(realloc->num_3body*SAFE_ZONE, MIN_3BODIES));

    if( !Make_List( num_bonds, realloc->num_3body, TYP_THREE_BODY, 
		    (*lists)+THREE_BODIES, comm ) ) {
      fprintf( stderr, "Problem in initializing angles list. Terminating!\n" );
      MPI_Abort( comm, CANNOT_INITIALIZE );
    }
    realloc->num_3body = -1;
  }

#if defined(PURE_REAX)
  /* grid */
  if( renbr && realloc->gcell_atoms > -1 ) {
#if defined(DEBUG_FOCUS)
    fprintf(stderr, "reallocating gcell: g->max_atoms: %d\n", g->max_atoms);
#endif
    for( i = g->native_str[0]; i < g->native_end[0]; i++ )
      for( j = g->native_str[1]; j < g->native_end[1]; j++ )
	for( k = g->native_str[2]; k < g->native_end[2]; k++ ) {
	  // reallocate g->atoms
	  sfree( g->cells[i][j][k].atoms, "g:atoms" );  
	  g->cells[i][j][k].atoms = (int*) 
	    scalloc( realloc->gcell_atoms, sizeof(int), "g:atoms", comm);
	}
    realloc->gcell_atoms = -1;
  }

  /* mpi buffers */
  // we have to be at a renbring step - 
  // to ensure correct values at mpi_buffers for update_boundary_positions
  if( !renbr )
    mpi_flag = 0;
  // check whether in_buffer capacity is enough
  else if( system->max_recved >= system->est_recv * 0.90 ) 
    mpi_flag = 1;
  else {
    // otherwise check individual outgoing buffers
    mpi_flag = 0;
    for( p = 0; p < MAX_NBRS; ++p ) {
      nbr_pr   = &( system->my_nbrs[p] );
      nbr_data = &( mpi_data->out_buffers[p] );
      if( nbr_data->cnt >= nbr_pr->est_send * 0.90 ) {
	mpi_flag = 1;
	break;
      }
    }
  }

  if( mpi_flag ) {
#if defined(DEBUG_FOCUS)
    fprintf( stderr, "p%d: reallocating mpi_buf: old_recv=%d\n",
	     system->my_rank, system->est_recv );
    for( p = 0; p < MAX_NBRS; ++p ) 
      fprintf( stderr, "p%d: nbr%d old_send=%d\n", 
	       system->my_rank, p, system->my_nbrs[p].est_send );
#endif
    /* update mpi buffer estimates based on last comm */
    system->est_recv = MAX( system->max_recved*SAFER_ZONE, MIN_SEND );
    system->est_trans = 
      (system->est_recv * sizeof(boundary_atom)) / sizeof(mpi_atom);
    total_send = 0;
    for( p = 0; p < MAX_NBRS; ++p ) {
      nbr_pr   = &( system->my_nbrs[p] );
      nbr_data = &( mpi_data->out_buffers[p] );
      nbr_pr->est_send = MAX( nbr_data->cnt*SAFER_ZONE, MIN_SEND );
      total_send += nbr_pr->est_send;
    }
#if defined(DEBUG_FOCUS)
    fprintf( stderr, "p%d: reallocating mpi_buf: recv=%d send=%d total=%dMB\n",
	     system->my_rank, system->est_recv, total_send,
	     (int)((system->est_recv+total_send)*sizeof(boundary_atom)/
		   (1024*1024)));
    for( p = 0; p < MAX_NBRS; ++p ) 
      fprintf( stderr, "p%d: nbr%d new_send=%d\n", 
	       system->my_rank, p, system->my_nbrs[p].est_send );
#endif

    /* reallocate mpi buffers */
    Deallocate_MPI_Buffers( mpi_data );
    ret = Allocate_MPI_Buffers( mpi_data, system->est_recv, 
				system->my_nbrs, msg );
    if( ret != SUCCESS ) {
      fprintf( stderr, "%s", msg );
      fprintf( stderr, "terminating...\n" );
      MPI_Abort( comm, INSUFFICIENT_MEMORY );
    }
  }
#endif /*PURE_REAX*/

#if defined(DEBUG_FOCUS) 
  fprintf( stderr, "p%d @ step%d: reallocate done\n", 
	   system->my_rank, data->step );
  MPI_Barrier( comm );
#endif
}
Exemplo n.º 8
0
int main(int argc, char ** argv)
{
    linked_list_t * mylist = Init_List();
    
    for (int iterator = 0; iterator < 10; ++iterator)
    {
        Insert_At_Beginning(mylist, iterator);
    }
    
    if (10 != Count(mylist))
    {
        printf("Found %d items on the stack, instead of 10\n", Count(mylist));
        exit(1);
    }
    
    int expectedStacktop = 9;
    int stacktop = 0;
    while (! Empty(mylist))
    {
        Remove_From_Beginning(mylist, &stacktop);
        if (stacktop != expectedStacktop)
        {
            printf("Expected %d at the top of the stack but got %d\n", expectedStacktop, stacktop);
            exit(1);
        }
        if ( Count(mylist) != stacktop)
        {
            printf("Count(mylist) returned an unexpected number of items: %d\n", Count(mylist));
            exit(1);
        }
        --expectedStacktop;
    }
    if (0 != stacktop)
    {
        printf("Expected 0 now that we should be at the bottom of the stack, but got %d\n", stacktop);
        exit(1);
    }
    // If we got this far without calling exit, everything seems good.
    printf("Stack test of list worked for functions operating at the front.\n");
    
    // Now let's try it at the end of the list
    for (int iterator = 0; iterator < 10; ++iterator)
    {
        Insert_At_End(mylist, iterator);
    }
    
    if (10 != Count(mylist))
    {
        printf("Found %d items on the stack, instead of 10\n", Count(mylist));
        exit(1);
    }
    
    expectedStacktop = 9;
    stacktop = 0;
    while (! Empty(mylist))
    {
        Remove_From_End(mylist, &stacktop);
        if (stacktop != expectedStacktop)
        {
            printf("Expected %d at the top of the stack but got %d\n", expectedStacktop, stacktop);
            exit(1);
        }
        if ( Count(mylist) != stacktop)
        {
            printf("Count(mylist) returned an unexpected number of items: %d\n", Count(mylist));
            exit(1);
        }
        --expectedStacktop;
    }
    if (0 != stacktop)
    {
        printf("Expected 0 now that we should be at the bottom of the stack, but got %d\n", stacktop);
        exit(1);
    }
    // If we got this far without calling exit, everything seems good.
    printf("Stack test of list worked for functions operating at the end.\n");
    
    if (!Empty(mylist))
    {
        printf("Expected stack to be empty, but it is not.\n");
        exit(1);
    }
    
    int data = 0;
    for (int iterator = 0; iterator < 20; ++iterator)
    {
        data = rand() % 1000;
        printf("Adding %d to the list.\n", data);
        Insert_in_order(mylist, data);
    }
    
    Traverse(mylist, intPrinter);
    
    if (Count(mylist) != 20)
    {
        printf("Expected count of list after random insertion, should be 20 but it was %d\n", Count(mylist));
        exit(1);
    }
    
    Delete_List(mylist);
    free(mylist);
    mylist = NULL;
    return 0;
}