void htable_test_query_splitting(htable_ctx_t *ctx) {
uint64_t i;
for (i = 0; i < THREADS * HTABLE_BLOCK_SIZE; i++) {
ctx->table[i] = i;
}
uint64_t index = HTABLE_BLOCK_SIZE - 7;
query_chunk(ctx, index, 0);
sync_on_chunk(ctx, 0);
printf("query for index %lu: ", index);
for (i = 0; i < HTABLE_CHUNK_SIZE; i++) {
printf("%lu (%lu) - ", ctx->chunks[i],
upc_threadof(&ctx->table[index + i]));
}
printf("\n");
}
void htable_test_ownership(htable_ctx_t *ctx) {
uint64_t limit = THREADS * HTABLE_BLOCK_SIZE;
uint64_t i, prev, prev_i, curr;
for (i = 0; i < limit; i++) {
curr = upc_threadof(&ctx->table[i]);
if (i == 0) {
prev = curr;
prev_i = 0;
}
if (prev != curr) {
printf("table[%lu] .. table[%lu] is owned by thread %lu\n", prev_i, i - 1, prev);
prev = curr;
prev_i = i;
}
}
printf("table[%lu] .. table[%lu] is owned by thread %lu\n", prev_i, limit, curr);
}
size_t htable_owner(htable_ctx_t *ctx, uint64_t data) {
uint64_t h = hash(data & HTABLE_MASK_DATA);
return upc_threadof(&ctx->table[HTABLE_ADDR(h)]);
}
void upc_all_fwrite_shared_async( upcio_file_t *fh_shared,
shared void *buffer,
uint32_t blocksize,
upc_off_t size,
uint32_t nmemb,
int64_t *ret,
upc_flag_t sync_mode )
{
Plfs_fd *fd;
UPC_ADIO_Request request;
unsigned char *local_buf;
upc_off_t count, blocksize_byte, roundsize;
uint32_t round, i;
upc_off_t start_th, my_th;
int error_code;
shared unsigned char * buffer_char;
struct __struct_thread_upc_file_t *fh;
upc_off_t *dispsize;
upc_off_t *disparray;
upc_off_t disp;
upc_off_t extra;
uint32_t extra_block;
upc_off_t mpi_size;
upc_off_t nblocks;
/*------------------------------------------------------------------*/
/* the file handler has to be valid */
/*------------------------------------------------------------------*/
if( fh_shared == NULL )
return;
/*------------------------------------------------------------------*/
/* cast the local file handler into private ones */
/* hopefully doing so will increase performance */
/*------------------------------------------------------------------*/
fh = (struct __struct_thread_upc_file_t *)(fh_shared->th[MYTHREAD]);
fd = (Plfs_fd *)fh->adio_fd;
/*------------------------------------------------------------------*/
/* make sure the file is not opened with read only */
/*------------------------------------------------------------------*/
if( fh->flags & UPC_RDONLY )
return;
/*------------------------------------------------------------------*/
/* make sure there is no asynchrounouse ops pending */
/*------------------------------------------------------------------*/
if( fh->async_flag == 1 )
return;
/*------------------------------------------------------------------*/
/* set the asynchrounouse ops flag */
/*------------------------------------------------------------------*/
fh->async_flag = 1;
/*------------------------------------------------------------------*/
/* upc sync mode */
/*------------------------------------------------------------------*/
if( sync_mode & UPC_IN_NOSYNC )
;
else if( sync_mode & UPC_IN_MYSYNC )
upc_barrier;
else
upc_barrier;
count = size*nmemb;
blocksize_byte = blocksize*size;
if( fh->flags & UPC_INDIVIDUAL_FP )
{
if( blocksize )
{
roundsize = blocksize_byte * THREADS;
buffer_char = (shared unsigned char *)buffer;
start_th = upc_threadof( buffer_char );
local_buf=(unsigned char *)malloc(sizeof(unsigned char)*count);
my_th = start_th;
round = 0;
for(i=0; i<count-(count%blocksize_byte); i+=blocksize_byte)
{
upc_memget(&local_buf[i], buffer_char+round*roundsize+my_th-start_th, blocksize_byte);
my_th++;
if(my_th == THREADS)
{
my_th = 0;
round++;
}
}
upc_memget(&local_buf[i], buffer_char+round*roundsize+my_th-start_th, count-i);
UPC_ADIO_IwriteContig( fd, local_buf, count, fh->private_pointer, &request,
ret, &error_code );
}
else
{
local_buf = (unsigned char *)malloc(sizeof(unsigned char)*count);
upc_memget(local_buf, buffer, count);
UPC_ADIO_IwriteContig( fd, local_buf, count, fh->private_pointer, &request,
ret, &error_code );
}
/*------------------------------------------------------------------*/
/* increment the file pointer */
/*------------------------------------------------------------------*/
fh->private_pointer += count;
}
else
{
if( blocksize )
{
buffer_char = (shared unsigned char *)buffer;
start_th = upc_threadof( buffer_char );
roundsize = blocksize_byte * THREADS;
round = (uint32_t)(count / roundsize);
nblocks = (uint32_t)(count / blocksize_byte);
extra_block = nblocks%THREADS;
extra = count % blocksize_byte;
mpi_size = round * blocksize_byte;
round++;
if( MYTHREAD < start_th ) /* wrap around */
{
my_th = MYTHREAD + THREADS - start_th;
local_buf = (unsigned char *)(buffer_char + roundsize - start_th +MYTHREAD );
}
else
{
my_th = MYTHREAD - start_th;
local_buf = (unsigned char *)(buffer_char + my_th);
}
if( my_th < nblocks%THREADS )
mpi_size += blocksize_byte;
if( my_th == extra_block )
mpi_size += extra;
disp = fh->shared_pointer + blocksize_byte * my_th;
disparray = (upc_off_t *)malloc(round*sizeof(upc_off_t));
dispsize = (upc_off_t *)malloc(round*sizeof(upc_off_t));
for( i=0; i<round; i++ )
{
disparray[i] = disp + i * roundsize;
dispsize[i] = blocksize_byte;
}
UPC_ADIO_IwriteStrided( fd, 1, &local_buf, &mpi_size, round, disparray, dispsize, &request,
ret, &error_code );
/*------------------------------------------------------------------*/
/* update the metadata */
/*------------------------------------------------------------------*/
fh->disparray = disparray;
fh->dispsize = dispsize;
}
else
{
//if( MYTHREAD == upc_threadof(buffer) )
if( MYTHREAD == 0 )
{
local_buf = (unsigned char *)malloc(sizeof(unsigned char)*count);
upc_memget(local_buf, buffer, count);
UPC_ADIO_IwriteContig( fd, local_buf, count, fh->shared_pointer, &request,
ret, &error_code );
}
}
/*------------------------------------------------------------------*/
/* increment the file pointer */
/*------------------------------------------------------------------*/
fh->shared_pointer += count;
}
/*------------------------------------------------------------------*/
/* update the metadata */
/*------------------------------------------------------------------*/
fh->request = request;
fh->async_op = __REF_UPC_WRITE_SHARED_ASYNC;
fh->local_ptr = local_buf;
fh->blocksize = blocksize_byte;
fh->size = count;
/*------------------------------------------------------------------*/
/* upc sync mode */
/*------------------------------------------------------------------*/
if( sync_mode & UPC_IN_NOSYNC )
;
else if( sync_mode & UPC_IN_MYSYNC )
upc_barrier;
else
upc_barrier;
return;
}
