Beispiel #1
0
BitHandle
BitField::get_handle()
{

  // find first free bit

  // first find first free word
  unsigned int word;
  for (word = 0 ; word < f_num_words ; word++ )
    if ( word_has_zero_bit(f_bits_in_use[word]) )
      break;

  if (word == f_num_words)
    {
      check_allocation (word);
#if 0
    // have to allocate more 
    unsigned long *new_words = new unsigned long [f_num_words + 1] ;
    unsigned long *new_use   = new unsigned long [f_num_words + 1] ;

    for (int i = 0 ; i < f_num_words ; i++ ){
      // copy old info 
      new_words[i] = f_words[i] ;
      new_use[i] = f_bits_in_use[i] ;
    }

    // zero out newest memory
    new_words[f_num_words] = 0 ;
    new_use[f_num_words] = 0 ;

    delete f_words ;
    f_words = new_words ;
    delete f_bits_in_use ;
    f_bits_in_use = new_use ;
    f_num_words++ ;
#endif
    return get_handle();	// NOTE: recursive and function exit
  }


  // now find first free byte in word 
  int byte;
  for (byte = 0 ; byte < bytes_per_word ; byte++ )
    if (byte_has_zero_bit(get_byte(byte, f_bits_in_use[word])))
      break;
  
  unsigned char the_byte = (unsigned char)
    (f_bits_in_use[word] >> (byte * bits_per_byte)) & 0xFF ;

  // now check byte for zero bit
  int bit;
  for (bit = 0 ; bit < bits_per_byte ; bit++ )
    if ((the_byte & mask[bit]) == 0)
      break ;

  // mark the bit as in use 
  f_bits_in_use[word] |= 1 << ((byte * bits_per_byte) + bit) ;
  
  return (word * bits_per_word) + (byte * bits_per_byte) + bit ;
}
int allocate_send_lists(int myrank, int *nghb_cnt, int** nghb_to_rank, int** send_cnt, 
        int*** send_lst, int **recv_cnt) {
    MPI_Status status;
    int nghb_idx=0;
    // Allocate send_cnt
    *send_cnt = (int*) calloc(sizeof(int), *nghb_cnt);
    // Send size of receive list for that processor, it will be equal to the size of send list of
    // received processor
    for (nghb_idx=0; nghb_idx<(*nghb_cnt); ++nghb_idx) {
        // Send sizes
        MPI_Send(&(*recv_cnt)[nghb_idx], 1, MPI_INT, (*nghb_to_rank)[nghb_idx], myrank, MPI_COMM_WORLD);
        // Receive sizes
        MPI_Recv(&(*send_cnt)[nghb_idx],1 , MPI_INT, (*nghb_to_rank)[nghb_idx], 
                (*nghb_to_rank)[nghb_idx], MPI_COMM_WORLD, &status);
    }
    // Allocate send_lst with given sizes
    *send_lst = (int**) malloc((*nghb_cnt)*sizeof(int*));
    check_allocation(myrank, send_lst, "malloc of send_lst failed");
    
    for (nghb_idx=0; nghb_idx<(*nghb_cnt); ++nghb_idx) {
        (*send_lst)[nghb_idx] = (int *) malloc((*send_cnt)[nghb_idx]*sizeof(int));
    }
    
    return POSL_OK;
}
Beispiel #3
0
struct lsh_iterator*
lsh_initialize(int len1, int len2, int(*penalty_)(int, int),
    int bandwidth, int *result)
{
  struct lsh_iterator* ret;
  assert (!busy);
  busy = 1;
  n1 = len1 + 1, n2 = len2 + 1;
  /* this is ugly comunication between lsh_initialize_mcmp and lsh_initialize
   * to check if we have mpenalty
   */
  if (bandwidth < 0) {
    bandwidth *= -1;
  } else {
    mpenalty = NULL;
    mmpenalty = NULL;
  }
  penalty = penalty_;
  K = bandwidth;
  adjust_bandwidth();
  double_K_plus_1 = 2*K + 1;
  check_allocation();
  edit_distance();
  output();
  if (result != NULL) {
    *result = dp_read[n2 - n1 + K];
  }
  ret = (struct lsh_iterator*) malloc(sizeof(struct lsh_iterator));
  ret->_row = n1 - 1;
  ret->_col = n2 - n1 + K;
  return ret;
}
Beispiel #4
0
void initiate_inode_list() {

    int arr[512];
    memset(arr,0 ,sizeof(arr));
    int i;

    uint max_inode_block = 1 + curr_superblock.isize;
    for(i = 2; i <= max_inode_block; i++)
        write_block(i, arr, sizeof(arr));

    //int brr[512];
    //read_block(20,brr,512);

    uint inode_number = curr_superblock.isize * INODES_PER_BLOCK;
    for(i = 2; i <= inode_number; i++) {
        if(curr_superblock.ninode == MAX_SIZE) 
            break;
        struct inode ino;
        read_inode(i, &ino);
        if(check_allocation(&ino) != 1) {
            free_inode(i);    
        }
    }
    if(curr_superblock.ninode == 0){ 
        fprintf(stderr,"Error: the inode blocks are full, allocation falure!");
        exit(-1);
    }
}
int allocate_lcc_elems_points(int read_key, int myrank, int nprocs, int *nintci, int *nintcf, int *nextci,
        int ***lcc, int* points_count, int*** points, int** elems, int **local_global_index, 
        int points_count_g, int *int_cells_per_proc) {
    int i=0;
    MPI_Status status;
    //starting index is same for all processors
    *nintci = 0;
    if (read_key == POSL_INIT_ONE_READ) {
        if (myrank == 0) {
            *points_count = points_count_g;
            for (i=1; i<nprocs; i++) {
                MPI_Send(&int_cells_per_proc[i], 1, MPI_INT, i, POSL_MPI_TAG_NINTCF, MPI_COMM_WORLD);
                MPI_Send(&points_count_g, 1, MPI_INT, i, POSL_MPI_TAG_POINTS_COUNT, MPI_COMM_WORLD);
            }
        } else {
            MPI_Recv(nintcf, 1, MPI_INT, 0, POSL_MPI_TAG_NINTCF, MPI_COMM_WORLD, &status);
            MPI_Recv(points_count, 1, MPI_INT, 0, POSL_MPI_TAG_POINTS_COUNT, MPI_COMM_WORLD, &status);
            //decrement the value, since our indexing starts from zero
            *nextci = *nintcf;
            --(*nintcf);
        }
    } else {
        *points_count = points_count_g;
    }
    
    *lcc = (int**) malloc(((*nintcf)+1)*sizeof(int*));
    check_allocation(myrank, lcc, "Failed to allocate first dimension of LCC");
    
    for (i=0; i<(*nintcf)+1; i++) {
        (*lcc)[i] = (int *) malloc(6*sizeof(int));
        check_allocation(myrank, lcc+i, "malloc failed to allocate second dimension of lcc");
    }
    
    *elems = (int *) malloc(((*nintcf)+1)*8*sizeof(int));
    check_allocation(myrank, elems, "Failed to allocate memory for elems");
    
    *points = (int **) calloc(*points_count, sizeof(int*));
    check_allocation(myrank, elems, "Failed to allocate memory for points 1st dimention");
    
    for (i=0; i<*points_count; i++) {
        (*points)[i] = (int *) calloc(3, sizeof(int));
        check_allocation(myrank, points+i, "malloc() POINTS 2nd dim. failed");
    }
    
    return POSL_OK;
}
int fill_l2g(int read_key, int myrank, int nproc, int nintcf, int** local_global_index, 
        int ***local_global_index_g, int *partitioning_map, int nelems_g, int *int_cells_per_proc) {
    int i=0, local_idx=0, current_proc=0;
    
    *local_global_index = (int *) malloc(((nintcf)+1)*sizeof(int));
    check_allocation(myrank, local_global_index, "Malloc for local_global_index failed");

    for (i=0; i<nelems_g; ++i) {
        if (partitioning_map[i] == myrank) {
            (*local_global_index)[local_idx] = i;
            ++local_idx;
        }
    }

    if (read_key == POSL_INIT_ONE_READ && myrank == 0) {        
        *local_global_index_g = (int**) malloc(nproc*sizeof(int*));
        check_allocation(myrank, local_global_index_g, "malloc failed to allocate first dimension of l2g_g");
        
        for (i=0; i<nproc; i++) {
            (*local_global_index_g)[i] = (int*) malloc(int_cells_per_proc[i]*sizeof(int));
            check_allocation(myrank, (local_global_index_g+i), "malloc failed to allocate 2nd dimension of l2g_g");
        }

        //initialize array of local indexes
        int last_local_idx[nproc];
        for (i=0; i<nproc; ++i) {
            last_local_idx[i] = 0;
        }
        
        for (i=0; i<nelems_g; ++i) {
            current_proc = partitioning_map[i];
            local_idx = last_local_idx[current_proc];
            
            if (local_idx > int_cells_per_proc[current_proc]) {
                log_err("Wrong local index for processor #%d", current_proc);
                return POSL_ERROR;
            }
            
            (*local_global_index_g)[current_proc][local_idx] = i;
            ++(last_local_idx[current_proc]);
        }
    }
    
    return POSL_OK;
}
Beispiel #7
0
bool
BitField::i_is_set(BitHandle handle)
{
  assert(handle);
  unsigned long word = handle / bits_per_word ;
  check_allocation (word);

  unsigned long mask = 1 << (handle % bits_per_word) ;

  return (f_words[word] & mask) != 0 ;
}
Beispiel #8
0
bool
BitField::i_unset(BitHandle handle)
{
  assert(handle);
  unsigned long word = handle / bits_per_word ;
  check_allocation (word);

  unsigned long mask = 1 << (handle % bits_per_word) ;

  f_words[word] &= ~0L ^ mask ;

  return 0 ;
}
Beispiel #9
0
bool
BitField::i_set(BitHandle handle)
{
  assert(handle);
  unsigned long word = handle / bits_per_word ;
  check_allocation (word);

  unsigned long mask = 1 << (handle % bits_per_word) ;

  ON_DEBUG (printf ("BitField: setting bit %ld (in word %ld)\n", handle, word));

  f_words[word] |= mask ;

  return 1 ;
}
int partition(int part_key, int read_key, int myrank, int nprocs, int nintci_g, 
        int nintcf_g, int nextci_g, int nextcf_g, int *nintci, int *nintcf, int *nextci, int *nextcf, 
        int **lcc_g, int points_count_g, int **points_g, int *elems_g, int *int_cells_per_proc, 
        int *extcell_per_proc, int **local_global_index_g, int **local_global_index, int **partitioning_map) {
    int i=0;
    idx_t nelems, nnodes, ncommon=4, nparts, objval;
    idx_t *elem_ptr, *elem_idx, *elem_part, *node_part;
    
    nelems = nintcf_g-nintci_g+1;
    *partitioning_map = (int *) calloc(sizeof(int), (nintcf_g-nintci_g+1));
    check_allocation(myrank, partitioning_map, "Partitioning map allocation failed");
    
    if (((read_key == POSL_INIT_ONE_READ) && (myrank == 0)) || (read_key == POSL_INIT_ALL_READ)) {
        *nintci = 0; *nintcf = 0;
        if (part_key == POSL_PARTITIONING_CLASSIC) {
            //the last processor always gets different number of cells
            int elem_per_proc = (nelems+(nprocs-1))/nprocs;
            *nextci = (myrank == nprocs-1) ? nelems-(nprocs-1)*elem_per_proc : elem_per_proc;
            *nintcf = *nextci-1;
            
            //build global cell allocation
            if (read_key == POSL_INIT_ONE_READ) {
                for (i=0; i<(nprocs-1); ++i) {
                    int_cells_per_proc[i] = elem_per_proc;
                }
                int_cells_per_proc[nprocs-1] = nelems-(nprocs-1)*elem_per_proc;
            }
                        
            for (i=0; i<nelems; ++i) {
                (*partitioning_map)[i] = i/elem_per_proc;
            }
        } else {
            //initialize variables for metis
            nnodes = points_count_g;
            nparts = nprocs;
            elem_ptr = (idx_t *) calloc(nelems+1, sizeof(idx_t));
            elem_idx = (idx_t *) calloc(nelems*8, sizeof(idx_t));
            elem_part = (idx_t *) calloc(nelems, sizeof(idx_t));
            node_part = (idx_t *) calloc(nnodes, sizeof(idx_t));
            
            //assign arrays that store metis graph mesh
            for (i=0; i<(nelems+1); i++) {
                elem_ptr[i] = 8*i;
            }
            for (i=0; i<(nelems*8); i++) {
                elem_idx[i] = elems_g[i];
            }

            //perform metis partitioning
            if (part_key == POSL_PARTITIONING_DUAL) {
                METIS_PartMeshDual(&nelems, &nnodes, elem_ptr, elem_idx, NULL, NULL, &ncommon, 
                        &nparts, NULL, NULL, &objval, elem_part, node_part);
            } else {
                METIS_PartMeshNodal(&nelems, &nnodes, elem_ptr, elem_idx, NULL, NULL, &nparts, 
                        NULL, NULL, &objval, elem_part, node_part);
            }
            
            for (i=0; i<nelems; i++) {
                (*partitioning_map)[i] = (int) elem_part[i];
            }
            
            //initialize global cell counters
            if (read_key == POSL_INIT_ONE_READ) {
                for (i=0; i<nprocs; ++i) {
                    int_cells_per_proc[i] = 0;
                }
            }
            
            //TODO: consider performance gains when if statement is outside of the loop
            //compute position of last internal cell
            for (i=0; i<nelems; i++) {
                if (read_key == POSL_INIT_ONE_READ) {
                    int_cells_per_proc[(*partitioning_map)[i]] += 1;
                } else {
                    if (myrank == (*partitioning_map)[i]) {
                        (*nintcf) += 1;
                    }
                }
            }
            
            //assign local internal cell ending idx
            if (read_key == POSL_INIT_ONE_READ) {
                *nintcf = int_cells_per_proc[myrank];
            }
            *nextci = (*nintcf)--;
        }
    }
    return POSL_OK;
}
int build_lists_g2l_next(int nprocs, int myrank, int *partitioning_map, int nintcf_g, int nextcf_g, 
        int* nintcf, int* nextcf, int*** lcc, int** local_global_index, int** global_local_index, 
        int *nghb_cnt, int** nghb_to_rank, int **recv_cnt, int*** recv_lst) {
    /*********** Initialize and allocate g2l and tmp variables ************************************/
    int proc=0, i=0, j=0, is_ghost_cell=0, idx_g=-1, neighbor_rank=-1;
    int n_ghost_cells[nprocs], start_idx_per_proc[nprocs];
    int nghb_idx=0;
    memset(n_ghost_cells, 0, nprocs*sizeof(int));
    memset(start_idx_per_proc, 0, nprocs*sizeof(int));
    *nextcf = 0;
    // Used to check if we already saved the cel index
    int is_saved[nextcf_g+1];
    /** Lists for neighboring information */
    /// number of cells to be received from each neighbor (size: nprocs)
    int tmp_recv_cnt[nprocs];
    memset(tmp_recv_cnt, 0, nprocs*sizeof(int));
    // TODO: try not to use tmp_recv_lst and save all data immediately in revc_lst
    // lists of cells to be received from each neighbor (size: nprocs x recv_cnt[*])
    int *tmp_recv_lst[nprocs];

    *global_local_index = (int *) malloc((nextcf_g+1)*sizeof(int));
    check_allocation(myrank, global_local_index, "malloc(global_local_index) failed");
    
    // We will fill whole g2l by -1 for easier debugging
    for (i=0; i<=nextcf_g; ++i) {
        (*global_local_index)[i] = -1;
    }
    /*********** End initialize and allocate g2l and tmp variables ********************************/
    // TODO: We can do all work in one big loop but then we need to use the buffer before we allocate
    //    memory for tmp_recv_lst
    /************************ Start processing lcc and generating data ****************************/
    memset(is_saved, 0, (nextcf_g+1)*sizeof(int));
    // Count number of external cells and fill g2l with external cells, and fill tmp_recv_cnt
    for (i=0; i<=(*nintcf); ++i) {
        for (j=0; j<6; ++j) {
            idx_g = (*lcc)[i][j];
            if(idx_g<=nintcf_g) {
                neighbor_rank = partitioning_map[idx_g];
                is_ghost_cell = neighbor_rank != myrank;
            }

            if (!is_saved[idx_g]) {
                if((*lcc)[i][j] > nintcf_g) {
                    ++(*nextcf);
                    is_saved[idx_g] = 1;
                    (*global_local_index)[idx_g] = (*nintcf) + (*nextcf);
                } else if (is_ghost_cell) {
                    ++tmp_recv_cnt[neighbor_rank];
                    is_saved[idx_g] = 1;
                }
            }
        }
        // Fill g2l with internal cell
        (*global_local_index)[(*local_global_index)[i]] = i;
    }
    /// After the loop nextcf shows amount of elements
    *nextcf = *nintcf + *nextcf;

    // Allocate tmp_recv_lst
    for (proc=0; proc<nprocs; ++proc) {
        if(tmp_recv_cnt[proc] == 0) {
            tmp_recv_lst[proc] = NULL;
        } else {
            tmp_recv_lst[proc] = (int *) calloc(sizeof(int), tmp_recv_cnt[proc]);
        }
    }
    // Fill tmp_recv_list and g2l with ghost cells
    start_idx_per_proc[0]=0;
    for(proc=1; proc<nprocs; ++proc) {
        start_idx_per_proc[proc] = start_idx_per_proc[proc-1] + tmp_recv_cnt[proc-1];
    }
    memset(is_saved, 0, (nextcf_g+1)*sizeof(int));
    for (i=0; i<=(*nintcf); ++i) {
        for (j=0; j<6; ++j) {
            idx_g = (*lcc)[i][j];
            if(idx_g<=nintcf_g) {
                neighbor_rank = partitioning_map[idx_g];
                is_ghost_cell = neighbor_rank != myrank;
            } else {
                is_ghost_cell = 0;
            }
            if (is_ghost_cell && !is_saved[idx_g]) {
                is_saved[idx_g] = 1;
                tmp_recv_lst[neighbor_rank][n_ghost_cells[neighbor_rank]] = idx_g;
                ++n_ghost_cells[neighbor_rank];
                (*global_local_index)[idx_g] = (*nextcf) +
                        start_idx_per_proc[neighbor_rank] + n_ghost_cells[neighbor_rank];
            }
        }
    }

    // Count neighbors it is already set to zero in gccg.c
    for (proc=0; proc<nprocs; ++proc) {
        if (tmp_recv_cnt[proc] !=0) ++(*nghb_cnt);
    }

    // Allocate and fill nhb_to_rank
    *nghb_to_rank = (int *) malloc((*nghb_cnt)*sizeof(int));
    check_allocation(myrank, nghb_to_rank, "malloc(nghb_to_rank) failed");
    
    for (proc=0;proc<nprocs; ++proc) {
        if(tmp_recv_cnt[proc] !=0) {
            (*nghb_to_rank)[nghb_idx] = proc;
            ++nghb_idx;
        }
    }
    // Allocate and fill recv_cnt and recv_lst with global lcc indexing for further use
    *recv_cnt = (int*) calloc(sizeof(int), *nghb_cnt);
    for (nghb_idx=0; nghb_idx<(*nghb_cnt); ++nghb_idx) {
        (*recv_cnt)[nghb_idx] = tmp_recv_cnt[ (*nghb_to_rank)[nghb_idx] ];
    }
    *recv_lst = (int**) malloc( (*nghb_cnt)*sizeof(int*) );
    for (nghb_idx=0; nghb_idx<(*nghb_cnt); ++nghb_idx) {
        (*recv_lst)[nghb_idx] = (int *) malloc( (*recv_cnt)[nghb_idx] * sizeof(int) );
    }
    for (nghb_idx=0; nghb_idx<(*nghb_cnt); ++nghb_idx) {
        memcpy( (*recv_lst)[nghb_idx], tmp_recv_lst[ (*nghb_to_rank)[nghb_idx] ],
                (*recv_cnt)[nghb_idx]*sizeof(int) );
    }

    // Total number of external cells
    for (nghb_idx=0; nghb_idx<(*nghb_cnt); ++nghb_idx) {
        *nextcf += (*recv_cnt)[nghb_idx];
    }
    /************************ End processing lcc and generating data ******************************/
    // Free memory
    for (proc=0; proc<nprocs; ++proc) {
        free(tmp_recv_lst[proc]);
    }
    
    return POSL_OK;
}