bool CHeap1::CreateFromBuffer( void* buffer, uint size ) { pHeapMemoryStart = buffer; void *_start = (void*) ALIGNUP( (uint)buffer, AlignMent ); void *_end = (void*) ALIGNDOWN( (uint)buffer + size, AlignMent ); pHeapEnd = _end; pSentinel = (Node*)_start; Node* new_node = (Node*)_start + 1; pSentinel->pPrevMem = NULL; pSentinel->pNextMem = new_node; pSentinel->pPrevFree = NULL; pSentinel->pNextFree = new_node; new_node->pPrevMem = pSentinel; new_node->pNextMem = (Node*)_end; new_node->pPrevFree = pSentinel; new_node->pNextFree = NULL; }
void ADIOI_Calc_file_domains(ADIO_Offset *st_offsets, ADIO_Offset *end_offsets, int nprocs, int nprocs_for_coll, ADIO_Offset *min_st_offset_ptr, ADIO_Offset **fd_start_ptr, ADIO_Offset **fd_end_ptr, ADIO_Offset *fd_size_ptr) { /* Divide the I/O workload among "nprocs_for_coll" processes. This is done by (logically) dividing the file into file domains (FDs); each process may directly access only its own file domain. */ ADIO_Offset min_st_offset, max_end_offset, *fd_start, *fd_end, fd_size; ADIO_Offset alignment = *fd_size_ptr; int i; #ifdef AGG_DEBUG FPRINTF(stderr, "ADIOI_Calc_file_domains: %d aggregator(s)\n", nprocs_for_coll); #endif /* find min of start offsets and max of end offsets of all processes */ min_st_offset = st_offsets[0]; max_end_offset = end_offsets[0]; for (i=1; i<nprocs; i++) { min_st_offset = ADIOI_MIN(min_st_offset, st_offsets[i]); max_end_offset = ADIOI_MAX(max_end_offset, end_offsets[i]); } /* determine the "file domain (FD)" of each process, i.e., the portion of the file that will be "owned" by each process */ /* partition the total file access range equally among nprocs_for_coll processes */ if (alignment) { min_st_offset = ALIGNDOWN(min_st_offset, alignment); fd_size = ((max_end_offset - min_st_offset + 1) + nprocs_for_coll - 1)/nprocs_for_coll; fd_size = (fd_size + alignment -1 ) / alignment * alignment; } else { fd_size = ((max_end_offset - min_st_offset + 1) + nprocs_for_coll - 1)/nprocs_for_coll; } /* ceiling division as in HPF block distribution */ *fd_start_ptr = (ADIO_Offset *) ADIOI_Malloc(nprocs_for_coll*sizeof(ADIO_Offset)); *fd_end_ptr = (ADIO_Offset *) ADIOI_Malloc(nprocs_for_coll*sizeof(ADIO_Offset)); fd_start = *fd_start_ptr; fd_end = *fd_end_ptr; fd_start[0] = min_st_offset; fd_end[0] = min_st_offset + fd_size - 1; for (i=1; i<nprocs_for_coll; i++) { fd_start[i] = fd_end[i-1] + 1; fd_end[i] = fd_start[i] + fd_size - 1; } /* take care of cases in which the total file access range is not divisible by the number of processes. In such cases, the last process, or the last few processes, may have unequal load (even 0). For example, a range of 97 divided among 16 processes. Note that the division is ceiling division. */ for (i=0; i<nprocs_for_coll; i++) { if (fd_start[i] > max_end_offset) fd_start[i] = fd_end[i] = -1; if (fd_end[i] > max_end_offset) fd_end[i] = max_end_offset; } *fd_size_ptr = fd_size; *min_st_offset_ptr = min_st_offset; }