static size_t
ifreader_read (ifreader *reader, size_t size)
{
size_t bytesread = 0, bytesrem = 0;
ASSERT(reader);
bytesrem = (size_t) reader->endptr - (size_t) reader->cursor;
if (size > reader->max) {
if (__verbose)
MESG("\nExtending buffer (%ld bytes)...\n", size);
reader->buf = RENEW(reader->buf, size+1, unsigned char);
reader->max = size;
}
if (reader->unread > 0 && bytesrem < size) {
bytesread = MIN(reader->max - bytesrem, reader->unread);
memmove(reader->buf, reader->cursor, bytesrem);
reader->cursor = reader->buf;
reader->endptr = reader->buf + bytesrem;
if (fread(reader->endptr, 1, bytesread, reader->fp) != bytesread)
ERROR("Reading file failed.");
reader->endptr += bytesread;
reader->unread -= bytesread;
if (__verbose)
MESG("Reading more %ld bytes (%ld bytes remains in buffer)...\n", bytesread, bytesrem);
}
*reader->endptr = 0;
return bytesread + bytesrem;
}
static void
CIDFont_dofont (CIDFont *font)
{
if (!font || !font->indirect)
return;
if (__verbose)
MESG(":%s", font->ident);
if (__verbose > 1) {
if (font->fontname)
MESG("[%s]", font->fontname);
}
switch (font->subtype) {
case CIDFONT_TYPE0:
if(__verbose)
MESG("[CIDFontType0]");
if (CIDFont_get_flag(font, CIDFONT_FLAG_TYPE1))
CIDFont_type0_t1dofont(font);
else if (CIDFont_get_flag(font, CIDFONT_FLAG_TYPE1C))
CIDFont_type0_t1cdofont(font);
else
CIDFont_type0_dofont(font);
break;
case CIDFONT_TYPE2:
if(__verbose)
MESG("[CIDFontType2]");
CIDFont_type2_dofont(font);
break;
default:
ERROR("%s: Unknown CIDFontType %d.", CIDFONT_DEBUG_STR, font->subtype);
break;
}
}
void
texpdf_dump (const char *start, const char *end)
{
const char *p = start;
#define DUMP_LIMIT 50
MESG("\nCurrent input buffer is -->");
while (p < end && p < start + DUMP_LIMIT)
MESG("%c", *(p++));
if (p == start+DUMP_LIMIT)
MESG("...");
MESG("<--\n");
}
/*
* test file access by communicator besides COMM_WORLD.
* Split COMM_WORLD into two, one (even_comm) contains the original
* processes of even ranks. The other (odd_comm) contains the original
* processes of odd ranks. Processes in even_comm creates a file, then
* cloose it, using even_comm. Processes in old_comm just do a barrier
* using odd_comm. Then they all do a barrier using COMM_WORLD.
* If the file creation and cloose does not do correct collective action
* according to the communicator argument, the processes will freeze up
* sooner or later due to barrier mixed up.
*/
void
test_split_comm_access(char filenames[][PATH_MAX])
{
MPI_Comm comm;
MPI_Info info = MPI_INFO_NULL;
int color, mrc;
int newrank, newprocs;
hid_t fid; /* file IDs */
hid_t acc_tpl; /* File access properties */
herr_t ret; /* generic return value */
if (verbose)
printf("Independent write test on file %s %s\n",
filenames[0], filenames[1]);
color = mpi_rank%2;
mrc = MPI_Comm_split (MPI_COMM_WORLD, color, mpi_rank, &comm);
assert(mrc==MPI_SUCCESS);
MPI_Comm_size(comm,&newprocs);
MPI_Comm_rank(comm,&newrank);
if (color){
/* odd-rank processes */
mrc = MPI_Barrier(comm);
assert(mrc==MPI_SUCCESS);
}else{
/* even-rank processes */
/* setup file access template */
acc_tpl = H5Pcreate (H5P_FILE_ACCESS);
assert(acc_tpl != FAIL);
/* set Parallel access with communicator */
ret = H5Pset_fapl_mpio(acc_tpl, comm, info);
assert(ret != FAIL);
/* create the file collectively */
fid=H5Fcreate(filenames[color],H5F_ACC_TRUNC,H5P_DEFAULT,acc_tpl);
assert(fid != FAIL);
MESG("H5Fcreate succeed");
/* Release file-access template */
ret=H5Pclose(acc_tpl);
assert(ret != FAIL);
ret=H5Fclose(fid);
assert(ret != FAIL);
}
if (mpi_rank == 0){
mrc = MPI_File_delete(filenames[color], info);
assert(mrc==MPI_SUCCESS);
}
}
/* Scan for subfont IDs */
static int
scan_sfd_file (struct sfd_file_ *sfd, FILE *fp)
{
char *id;
char *q, *p;
int n, lpos = 0;
ASSERT( sfd && fp );
if (dpx_conf.verbose_level > 3) {
MESG("\nsubfont>> Scanning SFD file \"%s\"...\n", sfd->ident);
}
rewind(fp);
sfd->max_subfonts = sfd->num_subfonts = 0;
while ((p = readline(line_buf, LINE_BUF_SIZE, fp)) != NULL) {
lpos++;
for ( ; *p && isspace((unsigned char)*p); p++);
if (*p == 0)
continue; /* empty */
/* Saw non-wsp here */
for (n = 0, q = p; *p && !isspace((unsigned char)*p); p++, n++);
id = NEW(n + 1, char);
memcpy(id, q, n); id[n] = '\0';
if (sfd->num_subfonts >= sfd->max_subfonts) {
sfd->max_subfonts += 16;
sfd->sub_id = RENEW(sfd->sub_id, sfd->max_subfonts, char *);
}
if (dpx_conf.verbose_level > 3) {
MESG("subfont>> id=\"%s\" at line=\"%d\"\n", id, lpos);
}
sfd->sub_id[sfd->num_subfonts] = id;
sfd->num_subfonts++;
}
static uint8_t wid_game_map_key_event (widp w, const SDL_KEYSYM *key)
{
int action = PLAYER_ACTION_USE;
int change_selection_only = false;
if (wid_menu_visible) {
return (false);
}
tpp tp;
if (!player) {
wid_player_info_hide(true /* fast */);
wid_player_inventory_hide(true /* fast */);
return (true);
}
int redraw_action_bar = 0;
int action_bar_index = thing_stats_get_action_bar_index(player);
if (key->mod & KMOD_SHIFT) {
int weapon_switch_delta = 0;
switch (key->sym) {
case SDLK_LEFT:
weapon_switch_delta = -1;
break;
case SDLK_RIGHT:
weapon_switch_delta = 1;
break;
default:
break;
}
/*
* Weapon switch?
*/
if (!weapon_switch_delta) {
return (true);
}
/*
* Only switch between weapons
*/
int tries = THING_ACTION_BAR_MAX;
while (tries-- > 0) {
action_bar_index += weapon_switch_delta;
if (action_bar_index < 0) {
action_bar_index = THING_ACTION_BAR_MAX - 1;
}
if (action_bar_index >= THING_ACTION_BAR_MAX) {
action_bar_index = 0;
}
uint32_t id = player->stats.action_bar[action_bar_index].id;
if (!id) {
continue;
}
tp = id_to_tp(id);
if (!tp) {
continue;
}
/*
* Found a weapon, switch to it.
*/
change_selection_only = true;
break;
}
if (tries <= 0) {
return (true);
}
redraw_action_bar = 1;
} else {
switch (key->sym) {
case SDLK_1:
action_bar_index = 0;
redraw_action_bar = 1;
break;
case SDLK_2:
action_bar_index = 1;
redraw_action_bar = 1;
break;
case SDLK_3:
action_bar_index = 2;
redraw_action_bar = 1;
break;
case SDLK_4:
action_bar_index = 3;
redraw_action_bar = 1;
break;
case SDLK_5:
action_bar_index = 4;
redraw_action_bar = 1;
break;
case SDLK_6:
action_bar_index = 5;
redraw_action_bar = 1;
break;
case SDLK_7:
action_bar_index = 6;
redraw_action_bar = 1;
break;
case SDLK_8:
action_bar_index = 7;
redraw_action_bar = 1;
break;
case SDLK_9:
action_bar_index = 8;
redraw_action_bar = 1;
break;
case SDLK_0:
action_bar_index = 9;
redraw_action_bar = 1;
break;
case 'z':
debug = !debug;
CON("debug %d", debug);
return (true);
case 'd':
action = PLAYER_ACTION_DROP;
break;
case 'p':
action = PLAYER_ACTION_PAY;
break;
case '\t': {
/*
* Show the inventory.
*/
thing_statsp s;
s = &player->stats;
if (!wid_player_info_is_visible()) {
/*
* Show stats window.
*/
wid_player_stats_visible(s);
wid_player_info_visible(s, false /* fast */);
wid_player_inventory_visible(s, false /* fast */);
socket_tx_player_action(client_joined_server, player,
PLAYER_ACTION_PAUSE_GAME,
0 /* action_bar_index */,
false /* change_selection_only */);
} else {
/*
* Hide stats window.
*/
wid_player_stats_hide(s);
wid_player_info_hide(false /* fast */);
wid_player_inventory_hide(false /* fast */);
socket_tx_player_action(client_joined_server, player,
PLAYER_ACTION_RESUME_GAME,
0 /* action_bar_index */,
false /* change_selection_only */);
}
return (true);
}
case 's':
wid_choose_stats_visible();
socket_tx_player_action(client_joined_server, player,
PLAYER_ACTION_PAUSE_GAME,
0 /* action_bar_index */,
false /* change_selection_only */);
return (true);
case 'q':
if (client_level->is_test_level) {
wid_game_map_go_back_to_editor();
return (true);
}
wid_game_quit_visible();
return (true);
case SDLK_RETURN:
case ' ':
return (false);
default:
return (false);
}
}
uint32_t id = player->stats.action_bar[action_bar_index].id;
if (!id) {
MESG(WARNING, "Nothing in that slot");
return (true);
}
tp = id_to_tp(id);
if (!tp) {
MESG(WARNING, "No carried item is using that key");
return (true);
}
if (!client_joined_server) {
MESG(WARNING, "Not connected to server");
return (true);
}
if (redraw_action_bar) {
/*
* Assume the server will accept the change and update locally else it
* looks laggy.
*/
player_action_bar_changed_at = time_get_time_ms();
thing_stats_set_action_bar_index(player, action_bar_index);
wid_player_action_hide(true /* fast */, false /* player quit */);
wid_player_action_visible(&player->stats, true /* fast */);
wid_player_stats_redraw(true /* fast */);
}
socket_tx_player_action(client_joined_server, player,
action,
action_bar_index,
change_selection_only);
return (true);
}
void
phdf5readAll(char *filename)
{
hid_t fid1; /* HDF5 file IDs */
hid_t acc_tpl1; /* File access templates */
hid_t xfer_plist; /* Dataset transfer properties list */
hid_t file_dataspace; /* File dataspace ID */
hid_t mem_dataspace; /* memory dataspace ID */
hid_t dataset1, dataset2; /* Dataset ID */
DATATYPE data_array1[SPACE1_DIM1][SPACE1_DIM2]; /* data buffer */
DATATYPE data_origin1[SPACE1_DIM1][SPACE1_DIM2]; /* expected data buffer */
hsize_t start[SPACE1_RANK]; /* for hyperslab setting */
hsize_t count[SPACE1_RANK], stride[SPACE1_RANK]; /* for hyperslab setting */
herr_t ret; /* Generic return value */
MPI_Comm comm = MPI_COMM_WORLD;
MPI_Info info = MPI_INFO_NULL;
if (verbose)
printf("Collective read test on file %s\n", filename);
/* -------------------
* OPEN AN HDF5 FILE
* -------------------*/
/* setup file access template with parallel IO access. */
acc_tpl1 = H5Pcreate (H5P_FILE_ACCESS);
assert(acc_tpl1 != FAIL);
MESG("H5Pcreate access succeed");
/* set Parallel access with communicator */
ret = H5Pset_fapl_mpio(acc_tpl1, comm, info);
assert(ret != FAIL);
MESG("H5Pset_fapl_mpio succeed");
/* open the file collectively */
fid1=H5Fopen(filename,H5F_ACC_RDWR,acc_tpl1);
assert(fid1 != FAIL);
MESG("H5Fopen succeed");
/* Release file-access template */
ret=H5Pclose(acc_tpl1);
assert(ret != FAIL);
/* --------------------------
* Open the datasets in it
* ------------------------- */
/* open the dataset1 collectively */
dataset1 = H5Dopen2(fid1, DATASETNAME1, H5P_DEFAULT);
assert(dataset1 != FAIL);
MESG("H5Dopen2 succeed");
/* open another dataset collectively */
dataset2 = H5Dopen2(fid1, DATASETNAME2, H5P_DEFAULT);
assert(dataset2 != FAIL);
MESG("H5Dopen2 2 succeed");
/*
* Set up dimensions of the slab this process accesses.
*/
/* Dataset1: each process takes a block of columns. */
slab_set(start, count, stride, BYCOL);
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* fill dataset with test data */
dataset_fill(start, count, stride, &data_origin1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* set up the collective transfer properties list */
xfer_plist = H5Pcreate (H5P_DATASET_XFER);
assert(xfer_plist != FAIL);
ret=H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
assert(ret != FAIL);
MESG("H5Pcreate xfer succeed");
/* read data collectively */
ret = H5Dread(dataset1, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
xfer_plist, data_array1);
assert(ret != FAIL);
MESG("H5Dread succeed");
/* verify the read data with original expected data */
ret = dataset_vrfy(start, count, stride, &data_array1[0][0], &data_origin1[0][0]);
assert(ret != FAIL);
/* release all temporary handles. */
/* Could have used them for dataset2 but it is cleaner */
/* to create them again.*/
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
H5Pclose(xfer_plist);
/* Dataset2: each process takes a block of rows. */
slab_set(start, count, stride, BYROW);
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* fill dataset with test data */
dataset_fill(start, count, stride, &data_origin1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* set up the collective transfer properties list */
xfer_plist = H5Pcreate (H5P_DATASET_XFER);
assert(xfer_plist != FAIL);
ret=H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
assert(ret != FAIL);
MESG("H5Pcreate xfer succeed");
/* read data independently */
ret = H5Dread(dataset2, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
xfer_plist, data_array1);
assert(ret != FAIL);
MESG("H5Dread succeed");
/* verify the read data with original expected data */
ret = dataset_vrfy(start, count, stride, &data_array1[0][0], &data_origin1[0][0]);
assert(ret != FAIL);
/* release all temporary handles. */
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
H5Pclose(xfer_plist);
/*
* All reads completed. Close datasets collectively
*/
ret=H5Dclose(dataset1);
assert(ret != FAIL);
MESG("H5Dclose1 succeed");
ret=H5Dclose(dataset2);
assert(ret != FAIL);
MESG("H5Dclose2 succeed");
/* close the file collectively */
H5Fclose(fid1);
}
void
phdf5writeAll(char *filename)
{
hid_t fid1; /* HDF5 file IDs */
hid_t acc_tpl1; /* File access templates */
hid_t xfer_plist; /* Dataset transfer properties list */
hid_t sid1; /* Dataspace ID */
hid_t file_dataspace; /* File dataspace ID */
hid_t mem_dataspace; /* memory dataspace ID */
hid_t dataset1, dataset2; /* Dataset ID */
hsize_t dims1[SPACE1_RANK] =
{SPACE1_DIM1,SPACE1_DIM2}; /* dataspace dim sizes */
DATATYPE data_array1[SPACE1_DIM1][SPACE1_DIM2]; /* data buffer */
hsize_t start[SPACE1_RANK]; /* for hyperslab setting */
hsize_t count[SPACE1_RANK], stride[SPACE1_RANK]; /* for hyperslab setting */
herr_t ret; /* Generic return value */
MPI_Comm comm = MPI_COMM_WORLD;
MPI_Info info = MPI_INFO_NULL;
/* in support of H5Tuner Test */
MPI_Comm comm_test = MPI_COMM_WORLD;
MPI_Info info_test ;
int i_test, nkeys_test, flag_test;
char key[MPI_MAX_INFO_KEY], value[MPI_MAX_INFO_VAL+1];
char *libtuner_file = getenv("LD_PRELOAD");
/* in support of H5Tuner Test */
if (verbose)
printf("Collective write test on file %s\n", filename);
/* -------------------
* START AN HDF5 FILE
* -------------------*/
/* setup file access template with parallel IO access. */
acc_tpl1 = H5Pcreate (H5P_FILE_ACCESS);
assert(acc_tpl1 != FAIL);
MESG("H5Pcreate access succeed");
/* set Parallel access with communicator */
ret = H5Pset_fapl_mpio(acc_tpl1, comm, info);
assert(ret != FAIL);
MESG("H5Pset_fapl_mpio succeed");
/* create the file collectively */
fid1=H5Fcreate(filename,H5F_ACC_TRUNC,H5P_DEFAULT,acc_tpl1);
assert(fid1 != FAIL);
MESG("H5Fcreate succeed");
// ------------------------------------------------
// H5Tuner tests
// ------------------------------------------------
// Retrieve MPI parameters set via the H5Tuner
printf("\n\n--------------------------------------------------\n");
if ( (libtuner_file != NULL) && (strlen(libtuner_file) > 1) ){
printf("Version of the H5Tuner loaded: \n%s\n", libtuner_file);
}
else {
printf("No H5Tuner currently loaded.\n");
}
printf("--------------------------------------------------\n");
// Retrieve HDF5 Threshold and Alignment
hsize_t alignment[2];
size_t sieve_buf_size;
alignment[0]= 0; // threshold value
alignment[1]= 0; // alignment value
int ierr = H5Pget_alignment(acc_tpl1, &alignment[0], &alignment[1]);
printf("\n\n--------------------------------------------------\n");
printf("Testing values for Threshold and Alignment\n");
printf("--------------------------------------------------\n");
printf("Test value set to:88 \nRetrieved Threshold=%lu\n", alignment[0]);
printf("Test value set to:44 \nRetrieved Alignment=%lu\n", alignment[1]);
// Check Threshold
if ( alignment[0] == 88 ) {
printf("PASSED: Threshold Test\n");
}
else {
printf("FAILED: Threshold Test\n");
}
// Check Alignment
if ( alignment[1] == 44 ) {
printf("PASSED: Alignment Test\n");
}
else {
printf("FAILED: Alignment Test\n");
}
printf("--------------------------------------------------\n\n");
// Retrieve HDF5 sieve buffer size
ierr = H5Pget_sieve_buf_size(acc_tpl1, &sieve_buf_size);
printf("\n\n--------------------------------------------------\n");
printf("Testing values for Sieve Buffer Size\n");
printf("--------------------------------------------------\n");
printf("Test value set to:77 \nRetrieved Sieve Buffer Size=%lu\n", sieve_buf_size);
// Check sieve buffer size
if ( (int) sieve_buf_size == 77 ) {
printf("PASSED: Sieve Buffer Size Test\n");
}
else {
printf("FAILED: Sieve Buffer Size Test\n");
}
printf("--------------------------------------------------\n\n");
// Retrieve MPI parameters set via the H5Tuner
MPI_Info_create(&info_test);
ret = H5Pget_fapl_mpio(acc_tpl1, &comm_test, &info_test);
assert(ret != FAIL);
MESG("H5Pget_fapl_mpio succeed");
printf("-------------------------------------------------\n" );
printf("Testing parameters values via MPI_Info\n" );
printf("-------------------------------------------------\n" );
if(info_test == MPI_INFO_NULL) {
printf("MPI info object is null. No keys are available.\n");
}
else {
MPI_Info_get_nkeys(info_test, &nkeys_test);
//printf("MPI info has %d keys\n", nkeys_test);
if (nkeys_test <= 0) {
printf("MPI info has no keys\n");
}
else {
printf("MPI info has %d keys\n", nkeys_test);
for ( i_test=0; i_test < nkeys_test; i_test++) {
MPI_Info_get_nthkey( info_test, i_test, key );
MPI_Info_get( info_test, key, MPI_MAX_INFO_VAL, value, &flag_test );
printf( "Retrieved value for key %s is %s\n", key, value );
//fflush(stdout);
}
}
printf("-------------------------------------------------\n" );
MPI_Info_free(&info_test);
}
// end of H5Tuner tests
// ---------------------------------------
/* Release file-access template */
ret=H5Pclose(acc_tpl1);
assert(ret != FAIL);
/* --------------------------
* Define the dimensions of the overall datasets
* and create the dataset
* ------------------------- */
/* setup dimensionality object */
sid1 = H5Screate_simple (SPACE1_RANK, dims1, NULL);
assert (sid1 != FAIL);
MESG("H5Screate_simple succeed");
/* create a dataset collectively */
dataset1 = H5Dcreate2(fid1, DATASETNAME1, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset1 != FAIL);
MESG("H5Dcreate2 succeed");
/* create another dataset collectively */
dataset2 = H5Dcreate2(fid1, DATASETNAME2, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset2 != FAIL);
MESG("H5Dcreate2 2 succeed");
/*
* Set up dimensions of the slab this process accesses.
*/
/* Dataset1: each process takes a block of rows. */
slab_set(start, count, stride, BYROW);
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* fill the local slab with some trivial data */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* set up the collective transfer properties list */
xfer_plist = H5Pcreate (H5P_DATASET_XFER);
assert(xfer_plist != FAIL);
ret=H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
assert(ret != FAIL);
MESG("H5Pcreate xfer succeed");
/* write data collectively */
ret = H5Dwrite(dataset1, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
xfer_plist, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* release all temporary handles. */
/* Could have used them for dataset2 but it is cleaner */
/* to create them again.*/
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
H5Pclose(xfer_plist);
/* Dataset2: each process takes a block of columns. */
slab_set(start, count, stride, BYCOL);
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* put some trivial data in the data_array */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* fill the local slab with some trivial data */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* set up the collective transfer properties list */
xfer_plist = H5Pcreate (H5P_DATASET_XFER);
assert(xfer_plist != FAIL);
ret=H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
assert(ret != FAIL);
MESG("H5Pcreate xfer succeed");
/* write data independently */
ret = H5Dwrite(dataset2, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
xfer_plist, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* release all temporary handles. */
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
H5Pclose(xfer_plist);
/*
* All writes completed. Close datasets collectively
*/
ret=H5Dclose(dataset1);
assert(ret != FAIL);
MESG("H5Dclose1 succeed");
ret=H5Dclose(dataset2);
assert(ret != FAIL);
MESG("H5Dclose2 succeed");
/* release all IDs created */
H5Sclose(sid1);
/* close the file collectively */
H5Fclose(fid1);
}
static void server_alive_check (void)
{
gsocketp s;
if (single_player_mode) {
return;
}
sockets_quality_check();
TREE_WALK(sockets, s) {
if (!socket_get_server_side_client(s)) {
continue;
}
/*
* Don't kill off new born connections.
*/
if (socket_get_tx(s) < 200) {
LOG("Server: Sent %d packets to %s, quality %u",
socket_get_tx(s),
socket_get_remote_logname(s),
socket_get_quality(s));
continue;
}
if (socket_get_quality(s) < SOCKET_PING_FAIL_THRESHOLD) {
/*
* Clients try forever. Server clients disconnect.
*/
aplayerp p = socket_get_player(s);
if (s->server_side_client) {
MSG_SERVER_SHOUT_AT_ALL_PLAYERS(
POPUP,
0, 0,
"Connection lost to %s",
socket_get_remote_logname(s));
if (p) {
LOG("Server: \"%s\" (ID %u) dropped out from %s",
p->stats_from_client.pname,
p->key,
socket_get_remote_logname(s));
} else {
LOG("Server: Dropped connection to %s",
socket_get_remote_logname(s));
}
LOG("Server: Sent %d packets, quality %u",
socket_get_tx(s),
(socket_get_quality(s) < SOCKET_PING_FAIL_THRESHOLD));
} else {
MESG(POPUP, "Connection at %d%% quality",
socket_get_quality(s));
continue;
}
server_rx_client_leave_implicit(s);
socket_disconnect(s);
} else {
LOG("Server: Sent %d packets to %s, quality %u",
socket_get_tx(s),
socket_get_remote_logname(s),
socket_get_quality(s));
}
}
}
int ReadSrgtFile(char *fname, int scat, Surrogate **s, double eps)
{
FILE *fp;
int n;
int i;
int m;
int line;
int col, row, id, cat;
float frac;
char buffer[MAXLINE];
char buffer2[MAXLINE];
SurrogateList *sl = NULL;
SurrogateList *t;
double tooSmallToRead;
extern int comp_surr(const void *, const void *);
if ((fp = fopen(fname,"r")) == NULL) {
WARN2("Cannot open file for reading: ", fname);
n = -1;
return n;
}
/* skip header (1 line) */
for (i=0; i<1; i++) {
if (fgets(buffer, MAXLINE, fp) == NULL) {
WARN2("Cannot read the first line of surrogate file ", fname);
n = -1;
goto cleanup;
}
}
n = 0;
line = 1;
tooSmallToRead=eps/100;
while (fgets(buffer, MAXLINE, fp) != NULL) {
if ((strlen(buffer) > 0) && (buffer[0] != '#'))
{
trim(buffer,buffer2);
if (strlen(buffer2) > 0)
{
m = sscanf(buffer2,"%d %d %d %d %f", &cat, &id, &col, &row, &frac);
if (m != 5)
{
sprintf(buffer,
"Failed to read the five required values from line %d of file\n%s\n%s",
line, fname, buffer2);
WARN(buffer);
n = -1;
goto cleanup;
}
if(cat==scat)
{
//if (frac > tooSmallToRead)
//{
if (!new_surr(&sl, id, col, row, frac))
{
n = -1;
goto cleanup;
}
n++;
//}
//else /* if the surrogate value is really tiny, skip it */
//{
// sprintf(mesg,"Skipping line: %s",buffer2);
// MESG(mesg);
//}
}
}
}
line++;
}
sprintf(buffer,"Read %d entries for category %d from file %s",
n, scat, fname);
MESG(buffer);
if (n==0) goto cleanup;
*s = (Surrogate *)malloc(n*sizeof(Surrogate));
if (*s == NULL) {
WARN("Malloc failure in ReadSrgtFile");
n = -1;
goto cleanup;
}
t = sl;
for (i=0; i < n; i++) {
(*s)[i].id = t->id;
(*s)[i].col = t->col;
(*s)[i].row = t->row;
(*s)[i].frac = t->frac;
t = t->next;
}
qsort((*s), n, sizeof(Surrogate), comp_surr);
/* printing surrogate can be useful for debugging */
/*fprintf(stdout,"file = %s, cat = %d\n",fname, scat);
printsurr(*s, n);*/
/*
free_surr(sl);
*/
cleanup:
fclose(fp);
return n;
}
/* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= */
int main(int argc, char *argv[])
{
char *sfile1, *sfile2;
int scat1, scat2;
Surrogate *a, *b;
int n_items_a, n_items_b;
float eps;
debug_output = 1;
prog_name = argv[0];
MESG(prog_version);
/* process command line args */
if (argc != 6) {
fprintf(stderr,
"Usage: %s srgt_file1 srgt_category1 srgt_file2 srgt_category2 tolerance\n",
argv[0]);
return 1;
}
sfile1 = argv[1];
scat1 = atoi(argv[2]);
sfile2 = argv[3];
scat2 = atoi(argv[4]);
eps = (float)atof(argv[5]);
sprintf(mesg,"Tolerance = %f",eps);
MESG(mesg);
n_items_a = ReadSrgtFile(sfile1, scat1, &a, eps);
if (n_items_a < 0)
{
if (a != NULL) free(a);
ERROR(argv[0], "Could not read surrogate", 1);
return 1; /*error*/
}
if (n_items_a == 0) {
sprintf(mesg,
"No surrogate entries for category %d were found in file %s\n",
scat1, sfile1);
if (a != NULL) free(a);
ERROR(argv[0], mesg, 1);
}
n_items_b = ReadSrgtFile(sfile2, scat2, &b, eps);
if (n_items_b < 0)
{
if (a != NULL) free(a);
if (b != NULL) free(b);
ERROR(argv[0], "Could not read surrogate", 1);
return 1; /*error*/
}
if (n_items_b == 0) {
sprintf(mesg,
"No surrogate entries for category %d were found in file %s\n",
scat2, sfile2);
if (a != NULL) free(a);
if (b != NULL) free(b);
ERROR(argv[0], mesg, 2);
}
/*if (n_items_a != n_items_b) {
if (a != NULL) free(a);
if (b != NULL) free(b);
sprintf(mesg,
"The number of surrogate entries for categories %d and %d differs",
scat1, scat2);
ERROR(argv[0], mesg, 3);
}*/
if (!compare_surrogates(n_items_a, n_items_b, a, b, eps)) {
if (a != NULL) free(a);
if (b != NULL) free(b);
sprintf(mesg,"The surrogate values differ for categories %d and %d\n",
scat1, scat2);
ERROR(argv[0], mesg, 4);
}
MESG("The surrogate comparison was successful!\n");
return 0;
}
int compare_surrogates(int na, int nb, Surrogate *a, Surrogate *b, float eps)
{
int i = 0, j = 0;
int flag=1;
int numdiffs = 0;
int didbreak = 0;
while ((i < na) && (j < nb))
{
if (a[i].id != b[j].id) {
/* handle the case when they are out of sync due to small values */
while ((a[i].id < b[j].id) && (a[i].frac <= eps) && (i < na))
{
i++;
sprintf(mesg,"County mismatch: Skipping small value for i=%d, val=%f",
i, a[i-1].frac);
MESG(mesg);
}
while ((a[i].id > b[j].id) && (b[j].frac <= eps) && (j < nb))
{
j++;
sprintf(mesg,"County mismatch: Skipping small value for j=%d, val=%f",
j, b[j-1].frac);
MESG(mesg);
}
}
if (a[i].id != b[j].id)
{
sprintf(mesg,"County IDs differ: %d %d %d %f != %d %d %d %f",
a[i].id, a[i].col, a[i].row, a[i].frac,
b[j].id, b[j].col, b[j].row, b[j].frac);
MESG(mesg);
flag = 0;
didbreak = 1;
break;
}
if (a[i].col != b[j].col) {
while ((a[i].col < b[j].col) && (a[i].frac <= eps) && (i < na))
{
i++;
sprintf(mesg,"Column mismatch: Skipping small value for i=%d, val=%f",
i, a[i-1].frac);
MESG(mesg);
}
while ((a[i].col > b[j].col) && (b[j].frac <= eps) && (j < nb))
{
j++;
sprintf(mesg,"Column mismatch: Skipping small value for j=%d, val=%f",
j, b[j-1].frac);
MESG(mesg);
}
}
if (a[i].col != b[j].col) {
sprintf(mesg,"Grid cell columns differ: %d %d %d %f != %d %d %d %f",
a[i].id, a[i].col, a[i].row, a[i].frac,
b[j].id, b[j].col, b[j].row, b[j].frac);
MESG(mesg);
flag = 0;
didbreak = 1;
break;
}
if (a[i].row != b[j].row) {
while ((a[i].row < b[j].row) && (a[i].frac <= eps) && (i < na))
{
i++;
sprintf(mesg,"Row mismatch: Skipping small value for i=%d, val=%f",
i, a[i-1].frac);
MESG(mesg);
}
while ((a[i].row > b[j].row) && (b[j].frac <= eps) && (j < nb))
{
j++;
sprintf(mesg,"Row mismatch: Skipping small value for j=%d, val=%f",
j, b[j-1].frac);
MESG(mesg);
}
}
if (a[i].row != b[j].row) {
sprintf(mesg,"Grid cell rows differ: %d %d %d %f != %d %d %d %f",
a[i].id, a[i].col, a[i].row, a[i].frac,
b[j].id, b[j].col, b[j].row, b[j].frac);
MESG(mesg);
flag = 0;
didbreak = 1;
break;
}
#ifdef DEBUG
sprintf(mesg,
"n=%d Id=%d Col=%d Row=%d FRAC1=%f, FRAC2 = %f, DIFF=%f",
n, a[i].id, a[i].col, a[i].row,a[i].frac, b[j].frac, a[i].frac-b[j].frac);
MESG(mesg);
#endif
if (fabs(a[i].frac - b[j].frac) > eps) {
sprintf(mesg,
"Fractions differ for %d, %d, %d: %f vs %f, diff=%f",
a[i].id, a[i].col, a[i].row,a[i].frac, b[j].frac, a[i].frac-b[j].frac);
MESG(mesg);
flag = 0;
numdiffs++;
}
i++;
j++;
}
if (didbreak)
{
WARN("Comparison stopped because ID or grid cell differed");
return flag;
}
/* only fractions differed */
if (numdiffs > 0)
{
sprintf(mesg,"%d total differences out of %d possible\n",
numdiffs, na);
WARN(mesg);
}
return flag;
}
void
phdf5writeInd(char *filename)
{
hid_t fid1; /* HDF5 file IDs */
hid_t acc_tpl1; /* File access templates */
hid_t sid1; /* Dataspace ID */
hid_t file_dataspace; /* File dataspace ID */
hid_t mem_dataspace; /* memory dataspace ID */
hid_t dataset1, dataset2; /* Dataset ID */
hsize_t dims1[SPACE1_RANK] =
{SPACE1_DIM1,SPACE1_DIM2}; /* dataspace dim sizes */
DATATYPE data_array1[SPACE1_DIM1][SPACE1_DIM2]; /* data buffer */
hsize_t start[SPACE1_RANK]; /* for hyperslab setting */
hsize_t count[SPACE1_RANK], stride[SPACE1_RANK]; /* for hyperslab setting */
herr_t ret; /* Generic return value */
MPI_Comm comm = MPI_COMM_WORLD;
MPI_Info info = MPI_INFO_NULL;
/* in support of H5Tuner Test */
MPI_Comm comm_test = MPI_COMM_WORLD;
MPI_Info info_test ;
int i_test, nkeys_test, flag_test;
char key[MPI_MAX_INFO_KEY], value[MPI_MAX_INFO_VAL+1];
char *libtuner_file = getenv("LD_PRELOAD");
/* in support of H5Tuner Test */
if (verbose)
printf("Independent write test on file %s\n", filename);
/* -------------------
* START AN HDF5 FILE
* -------------------*/
/* setup file access template with parallel IO access. */
acc_tpl1 = H5Pcreate (H5P_FILE_ACCESS);
assert(acc_tpl1 != FAIL);
MESG("H5Pcreate access succeed");
/* set Parallel access with communicator */
ret = H5Pset_fapl_mpio(acc_tpl1, comm, info);
assert(ret != FAIL);
MESG("H5Pset_fapl_mpio succeed");
/* create the file collectively */
/* printf("prior to callig H5Fcreate test on file %s\n", filename); */
fid1 = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl1);
assert(fid1 != FAIL);
MESG("H5Fcreate succeed");
// ------------------------------------------------
// H5Tuner tests
// ------------------------------------------------
// Retrieve parameters set via the H5Tuner
printf("\n\n--------------------------------------------------\n");
if ( (libtuner_file != NULL) && (strlen(libtuner_file) > 1) ){
printf("Version of the H5Tuner loaded: \n%s\n", libtuner_file);
}
else {
printf("No H5Tuner currently loaded.\n");
}
printf("--------------------------------------------------\n");
// Retrieve HDF5 Threshold and Alignment
hsize_t alignment[2];
alignment[0]= 0; // threshold value
alignment[1]= 0; // alignment value
ret = H5Pget_alignment(acc_tpl1, &alignment[0], &alignment[1]);
assert(ret != FAIL);
if ( verbose ) {
MESG("H5Pget_alignment succeed. Values Retrieved");
printf("\n\n--------------------------------------------------\n");
printf("Testing values for Threshold\n");
printf("--------------------------------------------------\n");
printf("Test value set to:88 \nRetrieved Threshold=%lu\n", alignment[0]);
}
// Check Threshold
if ( alignment[0] == 88 ) {
if (verbose)
printf("PASSED: Threshold Test\n");
}
else {
ret = FAIL;
nerrors++;
printf("FAILED: Threshold Test\n");
}
assert(ret != FAIL);
MESG("Threshold Test succeed");
// end of H5Tuner tests
// ------------------------------------------------
/* Release file-access template */
ret = H5Pclose(acc_tpl1);
assert(ret != FAIL);
/* --------------------------
* Define the dimensions of the overall datasets
* and the slabs local to the MPI process.
* ------------------------- */
/* setup dimensionality object */
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
assert (sid1 != FAIL);
MESG("H5Screate_simple succeed");
/* create a dataset collectively */
dataset1 = H5Dcreate2(fid1, DATASETNAME1, H5T_NATIVE_INT, sid1,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset1 != FAIL);
MESG("H5Dcreate2 succeed");
/* create another dataset collectively */
dataset2 = H5Dcreate2(fid1, DATASETNAME2, H5T_NATIVE_INT, sid1,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset2 != FAIL);
MESG("H5Dcreate2 succeed");
/* set up dimensions of the slab this process accesses */
start[0] = mpi_rank*SPACE1_DIM1/mpi_size;
start[1] = 0;
count[0] = SPACE1_DIM1/mpi_size;
count[1] = SPACE1_DIM2;
stride[0] = 1;
stride[1] =1;
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* put some trivial data in the data_array */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* write data independently */
ret = H5Dwrite(dataset1, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
H5P_DEFAULT, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* write data independently */
ret = H5Dwrite(dataset2, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
H5P_DEFAULT, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* release dataspace ID */
H5Sclose(file_dataspace);
/* close dataset collectively */
ret=H5Dclose(dataset1);
assert(ret != FAIL);
MESG("H5Dclose1 succeed");
ret=H5Dclose(dataset2);
assert(ret != FAIL);
MESG("H5Dclose2 succeed");
/* release all IDs created */
H5Sclose(sid1);
/* close the file collectively */
H5Fclose(fid1);
}
void
phdf5write2(char *filename, hio_context_t context)
{
hid_t fid1; /* HDF5 file IDs */
hid_t acc_tpl1; /* File access templates */
hid_t sid1; /* Dataspace ID */
hid_t file_dataspace; /* File dataspace ID */
hid_t mem_dataspace; /* memory dataspace ID */
hid_t dataset1, dataset2; /* Dataset ID */
hsize_t dims1[SPACE1_RANK] =
{SPACE1_DIM1,SPACE1_DIM2}; /* dataspace dim sizes */
DATATYPE data_array1[SPACE1_DIM1][SPACE1_DIM2]; /* data buffer */
hsize_t start[SPACE1_RANK]; /* for hyperslab setting */
hsize_t count[SPACE1_RANK], stride[SPACE1_RANK]; /* for hyperslab setting */
herr_t ret; /* Generic return value */
ssize_t bytes_written;
hio_request_t req;
if (verbose)
printf("Collective write test on file %s\n", filename);
/* -------------------
* START AN HDF5 FILE
* -------------------*/
/* setup file access template with hio IO access. */
acc_tpl1 = H5Pcreate (H5P_FILE_ACCESS);
assert(acc_tpl1 != FAIL);
MESG("H5Pcreate access succeed");
H5FD_hio_set_write_io(&settings, H5FD_HIO_STRIDED);
H5FD_hio_set_write_blocking(&settings, H5FD_HIO_NONBLOCKING);
H5FD_hio_set_request(&settings, &req);
ret = H5Pset_fapl_hio(acc_tpl1, &settings);
assert(ret != FAIL);
MESG("H5Pset_fapl_hio succeed");
/* create the file collectively */
fid1=H5Fcreate(filename,0,H5P_DEFAULT,acc_tpl1);
assert(fid1 != FAIL);
MESG("H5Fcreate succeed");
/* Release file-access template */
ret=H5Pclose(acc_tpl1);
assert(ret != FAIL);
/* --------------------------
* Define the dimensions of the overall datasets
* and create the dataset
* ------------------------- */
/* setup dimensionality object */
sid1 = H5Screate_simple (SPACE1_RANK, dims1, NULL);
assert (sid1 != FAIL);
MESG("H5Screate_simple succeed");
/* create a dataset collectively */
dataset1 = H5Dcreate2(fid1, DATASETNAME1, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset1 != FAIL);
MESG("H5Dcreate2 succeed");
/* create another dataset collectively */
dataset2 = H5Dcreate2(fid1, DATASETNAME2, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset2 != FAIL);
MESG("H5Dcreate2 2 succeed");
/*
* Set up dimensions of the slab this process accesses.
*/
/* Dataset1: each process takes a block of rows. */
slab_set(start, count, stride, BYROW);
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* fill the local slab with some trivial data */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* write data strided and blocking*/
ret = H5Dwrite(dataset1, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
H5P_DEFAULT, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
//Wait for the request to finish
hio_request_wait(&req, 1, &bytes_written);
/* release all temporary handles. */
/* Could have used them for dataset2 but it is cleaner */
/* to create them again.*/
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
/* Dataset2: each process takes a block of columns. */
slab_set(start, count, stride, BYCOL);
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* put some trivial data in the data_array */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* fill the local slab with some trivial data */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
if (verbose){
MESG("data_array created");
dataset_print(start, count, stride, &data_array1[0][0]);
}
/* write data contiguous and blocking */
ret = H5Dwrite(dataset2, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
H5P_DEFAULT, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* release all temporary handles. */
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
/*
* All writes completed. Close datasets collectively
*/
ret=H5Dclose(dataset1);
assert(ret != FAIL);
MESG("H5Dclose1 succeed");
ret=H5Dclose(dataset2);
assert(ret != FAIL);
MESG("H5Dclose2 succeed");
/* release all IDs created */
H5Sclose(sid1);
/* close the file collectively */
H5Fclose(fid1);
}
void
phdf5write1(char *filename, hio_context_t context)
{
hid_t fid1; /* HDF5 file IDs */
hid_t acc_tpl1; /* File access templates */
hid_t sid1; /* Dataspace ID */
hid_t file_dataspace; /* File dataspace ID */
hid_t mem_dataspace; /* memory dataspace ID */
hid_t dataset1, dataset2; /* Dataset ID */
hsize_t dims1[SPACE1_RANK] =
{SPACE1_DIM1,SPACE1_DIM2}; /* dataspace dim sizes */
DATATYPE data_array1[SPACE1_DIM1][SPACE1_DIM2]; /* data buffer */
hsize_t start[SPACE1_RANK]; /* for hyperslab setting */
hsize_t count[SPACE1_RANK], stride[SPACE1_RANK]; /* for hyperslab setting */
herr_t ret; /* Generic return value */
if (verbose)
printf("Independent write test on file %s\n", filename);
/* -------------------
* START AN HDF5 FILE
* -------------------*/
/* setup file access template with hio IO access. */
acc_tpl1 = H5Pcreate (H5P_FILE_ACCESS);
assert(acc_tpl1 != FAIL);
MESG("H5Pcreate access succeed");
/* set HIO context */
H5FD_hio_set_write_io(&settings, H5FD_HIO_CONTIGUOUS);
H5FD_hio_set_write_blocking(&settings, H5FD_HIO_BLOCKING);
ret = H5Pset_fapl_hio(acc_tpl1, &settings);
assert(ret != FAIL);
MESG("H5Pset_fapl_hio succeed");
/* create the file/dataset collectively */
fid1 = H5Fcreate(filename, 0, H5P_DEFAULT, acc_tpl1);
assert(fid1 != FAIL);
MESG("H5Fcreate succeed");
/* Release file-access template */
ret = H5Pclose(acc_tpl1);
assert(ret != FAIL);
/* --------------------------
* Define the dimensions of the overall datasets
* and the slabs local to the MPI process.
* ------------------------- */
/* setup dimensionality object */
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
assert (sid1 != FAIL);
MESG("H5Screate_simple succeed");
/* create a dataset collectively */
dataset1 = H5Dcreate2(fid1, DATASETNAME1, H5T_NATIVE_INT, sid1,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset1 != FAIL);
MESG("H5Dcreate2 succeed");
/* create another dataset collectively */
dataset2 = H5Dcreate2(fid1, DATASETNAME2, H5T_NATIVE_INT, sid1,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
assert(dataset2 != FAIL);
MESG("H5Dcreate2 succeed");
/* set up dimensions of the slab this process accesses */
start[0] = mpi_rank*SPACE1_DIM1/mpi_size;
start[1] = 0;
count[0] = SPACE1_DIM1/mpi_size;
count[1] = SPACE1_DIM2;
stride[0] = 1;
stride[1] =1;
if (verbose)
printf("start[]=(%lu,%lu), count[]=(%lu,%lu), total datapoints=%lu\n",
(unsigned long)start[0], (unsigned long)start[1],
(unsigned long)count[0], (unsigned long)count[1],
(unsigned long)(count[0]*count[1]));
/* put some trivial data in the data_array */
dataset_fill(start, count, stride, &data_array1[0][0]);
MESG("data_array initialized");
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset1);
assert(file_dataspace != FAIL);
MESG("H5Dget_space succeed");
ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride,
count, NULL);
assert(ret != FAIL);
MESG("H5Sset_hyperslab succeed");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple (SPACE1_RANK, count, NULL);
assert (mem_dataspace != FAIL);
/* write data independently */
ret = H5Dwrite(dataset1, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
H5P_DEFAULT, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* write data independently */
ret = H5Dwrite(dataset2, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
H5P_DEFAULT, data_array1);
assert(ret != FAIL);
MESG("H5Dwrite succeed");
/* release dataspace ID */
H5Sclose(file_dataspace);
/* close dataset collectively */
ret=H5Dclose(dataset1);
assert(ret != FAIL);
MESG("H5Dclose1 succeed");
ret=H5Dclose(dataset2);
assert(ret != FAIL);
MESG("H5Dclose2 succeed");
/* release all IDs created */
H5Sclose(sid1);
/* close the file collectively */
H5Fclose(fid1);
}
static int
pk_decode_packed (pdf_obj *stream, long wd, long ht,
int dyn_f, int run_color, unsigned char *dp, long pl)
{
unsigned char *rowptr;
long rowbytes;
long i, np = 0;
long run_count = 0, repeat_count = 0;
rowbytes = (wd + 7) / 8;
rowptr = NEW(rowbytes, unsigned char);
/* repeat count is applied to the *current* row.
* "run" can span across rows.
* If there are non-zero repeat count and if run
* spans across row, first repeat and then continue.
*/
#ifdef DEBUG
MESG("\npkfont>> wd: %ld, ht: %ld, dyn_f: %d\n", wd, ht, dyn_f);
#endif
for (np = 0, i = 0; i < ht; i++) {
long rowbits_left, nbits;
repeat_count = 0;
memset(rowptr, 0xff, rowbytes); /* 1 is white */
rowbits_left = wd;
/* Fill run left over from previous row */
if (run_count > 0) {
nbits = MIN(rowbits_left, run_count);
switch (run_color) {
case 0:
rowbits_left -= fill_black_run(rowptr, 0, nbits);
break;
case 1:
rowbits_left -= fill_white_run(rowptr, 0, nbits);
break;
}
run_count -= nbits;
}
/* Read nybbles until we have a full row */
while (np / 2 < pl && rowbits_left > 0) {
int nyb;
nyb = (np % 2) ? dp[np/2] & 0x0f : (dp[np/2] >> 4) & 0x0f;
#if DEBUG == 3
MESG("\npk_nyb: %d", nyb);
#endif
if (nyb == 14) { /* packed number "repeat_count" follows */
if (repeat_count != 0)
WARN("Second repeat count for this row!");
np++; /* Consume this nybble */
repeat_count = pk_packed_num(&np, dyn_f, dp, pl);
#if DEBUG == 3
MESG(" --> rep: %ld\n", repeat_count);
#endif
} else if (nyb == 15) {
if (repeat_count != 0)
WARN("Second repeat count for this row!");
np++; /* Consume this nybble */
repeat_count = 1;
#if DEBUG == 3
MESG(" --> rep: %ld\n", repeat_count);
#endif
} else { /* run_count */
/* Interprete current nybble as packed number */
run_count = pk_packed_num(&np, dyn_f, dp, pl);
#if DEBUG == 3
MESG(" --> run: %ld (%d)\n", run_count, run_color);
#endif
nbits = MIN(rowbits_left, run_count);
run_color = !run_color;
run_count -= nbits;
switch (run_color) {
case 0:
rowbits_left -= fill_black_run(rowptr, wd - rowbits_left, nbits);
break;
case 1:
rowbits_left -= fill_white_run(rowptr, wd - rowbits_left, nbits);
break;
}
}
}
/* We got bitmap row data. */
#if DEBUG == 2
send_out(rowptr, rowbytes, wd, stream);
#else
send_out(rowptr, rowbytes, stream);
#endif
for ( ; i < ht && repeat_count > 0; repeat_count--, i++)
#if DEBUG == 2
send_out(rowptr, rowbytes, wd, stream);
#else
send_out(rowptr, rowbytes, stream);
#endif
}
RELEASE(rowptr);
return 0;
}
int compare_surrogates1(int n, Surrogate *a, Surrogate *b, float eps)
{
int i;
int flag=1;
int numdiffs = 0;
int didbreak = 0;
for (i=0; i<n; i++) {
if (a[i].id != b[i].id) {
sprintf(mesg,"County IDs differ: %d %d %d %f != %d %d %d %f",
a[i].id, a[i].col, a[i].row, a[i].frac,
b[i].id, b[i].col, b[i].row, b[i].frac);
MESG(mesg);
flag = 0;
didbreak = 1;
break;
}
if (a[i].col != b[i].col) {
sprintf(mesg,"Grid cell columns differ: %d %d %d %f != %d %d %d %f",
a[i].id, a[i].col, a[i].row, a[i].frac,
b[i].id, b[i].col, b[i].row, b[i].frac);
MESG(mesg);
flag = 0;
didbreak = 1;
break;
}
if (a[i].row != b[i].row) {
sprintf(mesg,"Grid cell rows differ: %d %d %d %f != %d %d %d %f",
a[i].id, a[i].col, a[i].row, a[i].frac,
b[i].id, b[i].col, b[i].row, b[i].frac);
MESG(mesg);
flag = 0;
didbreak = 1;
break;
}
#ifdef DEBUG
sprintf(mesg,
"n=%d Id=%d Col=%d Row=%d FRAC1=%f, FRAC2 = %f, DIFF=%f",
n, a[i].id, a[i].col, a[i].row,a[i].frac, b[i].frac, a[i].frac-b[i].frac);
MESG(mesg);
#endif
if (fabs(a[i].frac - b[i].frac) > eps) {
sprintf(mesg,
"Fractions differ for %d, %d, %d: %f vs %f, diff=%f",
a[i].id, a[i].col, a[i].row,a[i].frac, b[i].frac, a[i].frac-b[i].frac);
MESG(mesg);
flag = 0;
numdiffs++;
}
}
if (didbreak)
{
WARN("Comparison stopped because ID or grid cell differed");
return flag;
}
/* only fractions differed */
if (numdiffs > 0)
{
sprintf(mesg,"%d total differences out of %d possible\n",
numdiffs, n);
WARN(mesg);
}
return flag;
}
static int
load_encoding_file (const char *filename)
{
FILE *fp;
pdf_obj *enc_name = NULL;
pdf_obj *encoding_array = NULL;
char *wbuf;
const char *p, *endptr;
const char *enc_vec[256];
int code, fsize, enc_id;
if (!filename)
return -1;
if (dpx_conf.verbose_level > 0) {
MESG("(Encoding:%s", filename);
}
fp = DPXFOPEN(filename, DPX_RES_TYPE_ENC);
if (!fp)
return -1;
/*
* file_size do seek_end witout saving current position and
* do rewind.
*/
fsize = file_size(fp);
wbuf = NEW(fsize + 1, char);
wbuf[fsize] = '\0';
fread(wbuf, sizeof(char), fsize, fp);
DPXFCLOSE(fp);
p = wbuf;
endptr = wbuf + fsize;
skip_white(&p, endptr);
/*
* Skip comment lines.
*/
while (p < endptr && p[0] == '%') {
pdfparse_skip_line (&p, endptr);
skip_white(&p, endptr);
}
if (p[0] == '/')
enc_name = parse_pdf_name(&p, endptr);
skip_white(&p, endptr);
encoding_array = parse_pdf_array(&p, endptr, NULL);
RELEASE(wbuf);
if (!encoding_array) {
if (enc_name)
pdf_release_obj(enc_name);
return -1;
}
for (code = 0; code < 256; code++) {
enc_vec[code] = pdf_name_value(pdf_get_array(encoding_array, code));
}
enc_id = pdf_encoding_new_encoding(enc_name ? pdf_name_value(enc_name) : NULL,
filename, enc_vec, NULL, 0);
if (enc_name) {
if (dpx_conf.verbose_level > 1)
MESG("[%s]", pdf_name_value(enc_name));
pdf_release_obj(enc_name);
}
pdf_release_obj(encoding_array);
if (dpx_conf.verbose_level > 0) MESG(")");
return enc_id;
}
