static void
test_action_widgets (void)
{
GtkWidget *dialog;
GtkFileChooserAction action;
gboolean passed;
dialog = gtk_file_chooser_dialog_new ("Test file chooser",
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
gtk_widget_show_now (dialog);
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (dialog));
passed = test_widgets_for_current_action (GTK_FILE_CHOOSER_DIALOG (dialog), action);
log_test (passed, "test_action_widgets(): widgets for initial action %s", get_action_name (action));
g_assert (passed);
passed = foreach_action (GTK_FILE_CHOOSER_DIALOG (dialog), switch_from_action_cb, NULL);
log_test (passed, "test_action_widgets(): all transitions through property change");
g_assert (passed);
gtk_widget_destroy (dialog);
}
static void
test_button_folder_states (void)
{
/* GtkFileChooserButton only supports OPEN and SELECT_FOLDER */
static const GtkFileChooserAction actions_to_test[] = {
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
};
gboolean passed;
int i;
passed = TRUE;
for (i = 0; i < G_N_ELEMENTS (actions_to_test); i++)
{
passed = passed && test_button_folder_states_for_action (actions_to_test[i], FALSE, FALSE);
g_assert (passed);
passed = passed && test_button_folder_states_for_action (actions_to_test[i], TRUE, FALSE);
g_assert (passed);
passed = passed && test_button_folder_states_for_action (actions_to_test[i], TRUE, TRUE);
g_assert (passed);
log_test (passed, "test_button_folder_states(): action %s", get_action_name (actions_to_test[i]));
}
log_test (passed, "test_button_folder_states(): all supported actions");
}
static gboolean
switch_from_to_action_cb (GtkFileChooserDialog *dialog,
GtkFileChooserAction action,
gpointer user_data)
{
struct action_closure *closure;
gboolean passed;
closure = user_data;
gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), closure->from_action);
passed = test_widgets_for_current_action (dialog, closure->from_action);
log_test (passed, "switch_from_to_action_cb(): reset to action %s", get_action_name (closure->from_action));
if (!passed)
return FALSE;
gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), action);
passed = test_widgets_for_current_action (dialog, action);
log_test (passed, "switch_from_to_action_cb(): transition from %s to %s",
get_action_name (closure->from_action),
get_action_name (action));
return passed;
}
static void
test_reload (void)
{
gboolean passed;
passed = test_reload_sequence (FALSE);
log_test (passed, "test_reload(): create and use the default folder");
g_assert (passed);
passed = test_reload_sequence (TRUE);
log_test (passed, "test_reload(): set a folder explicitly before mapping");
g_assert (passed);
}
/**************************************************************************
Print results
**************************************************************************/
void TIMING_RESULTS(void)
{
char buf[200];
#ifdef LOG_TIMERS
#define AILOG_OUT(text, which) \
fc_snprintf(buf, sizeof(buf), " %s: %g sec turn, %g sec game", text, \
timer_read_seconds(aitimer[which][0]), \
timer_read_seconds(aitimer[which][1])); \
log_test("%s", buf); \
notify_conn(NULL, NULL, E_AI_DEBUG, ftc_log, "%s", buf);
log_test(" --- AI timing results ---");
#else /* LOG_TIMERS */
#define AILOG_OUT(text, which) \
fc_snprintf(buf, sizeof(buf), " %s: %g sec turn, %g sec game", text, \
timer_read_seconds(aitimer[which][0]), \
timer_read_seconds(aitimer[which][1])); \
notify_conn(NULL, NULL, E_AI_DEBUG, ftc_log, "%s", buf);
#endif /* LOG_TIMERS */
notify_conn(NULL, NULL, E_AI_DEBUG, ftc_log,
" --- AI timing results ---");
AILOG_OUT("Total AI time", AIT_ALL);
AILOG_OUT("Movemap", AIT_MOVEMAP);
AILOG_OUT("Units", AIT_UNITS);
AILOG_OUT(" - Military", AIT_MILITARY);
AILOG_OUT(" - Attack", AIT_ATTACK);
AILOG_OUT(" - Defense", AIT_DEFENDERS);
AILOG_OUT(" - Ferry", AIT_FERRY);
AILOG_OUT(" - Rampage", AIT_RAMPAGE);
AILOG_OUT(" - Bodyguard", AIT_BODYGUARD);
AILOG_OUT(" - Recover", AIT_RECOVER);
AILOG_OUT(" - Caravan", AIT_CARAVAN);
AILOG_OUT(" - Hunter", AIT_HUNTER);
AILOG_OUT(" - Airlift", AIT_AIRLIFT);
AILOG_OUT(" - Diplomat", AIT_DIPLOMAT);
AILOG_OUT(" - Air", AIT_AIRUNIT);
AILOG_OUT(" - Explore", AIT_EXPLORER);
AILOG_OUT("fstk", AIT_FSTK);
AILOG_OUT("Settlers", AIT_SETTLERS);
AILOG_OUT("Workers", AIT_WORKERS);
AILOG_OUT("Government", AIT_GOVERNMENT);
AILOG_OUT("Taxes", AIT_TAXES);
AILOG_OUT("Cities", AIT_CITIES);
AILOG_OUT(" - Buildings", AIT_BUILDINGS);
AILOG_OUT(" - Danger", AIT_DANGER);
AILOG_OUT(" - Worker want", AIT_CITY_TERRAIN);
AILOG_OUT(" - Military want", AIT_CITY_MILITARY);
AILOG_OUT(" - Settler want", AIT_CITY_SETTLERS);
AILOG_OUT("Citizen arrange", AIT_CITIZEN_ARRANGE);
AILOG_OUT("Tech", AIT_TECH);
}
/**********************************************************************
Report if time() returns -1, but only the first time.
Ignore this timer from now on.
***********************************************************************/
static void report_time_failed(struct timer *t)
{
static bool first = TRUE;
if (first) {
log_test("time() returned -1, ignoring timer");
first = FALSE;
}
t->use = TIMER_IGNORE;
}
END_TEST
START_TEST (check_mail_headers_s) {
log_disable();
bool_t result = true;
stringer_t *errmsg = MANAGEDBUF(1024);
if (status()) result = check_mail_headers_sthread(errmsg);
log_test("MAIL / HEADERS / SINGLE THREADED:", errmsg);
ck_assert_msg(result, st_char_get(errmsg));
}
static gboolean
test_black_box_set_filename (GtkFileChooserAction action, const char *filename, gboolean focus_button)
{
gboolean passed;
passed = test_set_filename (action, focus_button, set_filename_cb, compare_filename_cb, (char *) filename);
log_test (passed, "set_filename: action %d, focus_button=%s",
(int) action,
focus_button ? "TRUE" : "FALSE");
return passed;
}
END_TEST
START_TEST (check_mail_store_s) {
log_disable();
bool_t result = true;
stringer_t *errmsg = MANAGEDBUF(1024);
if (status()) result = check_mail_store_plaintext_sthread(errmsg);
if (status() && result) result = check_mail_store_encrypted_sthread(errmsg);
log_test("MAIL / STORE / SINGLE THREADED:", errmsg);
ck_assert_msg(result, st_char_get(errmsg));
}
static gboolean
test_black_box_set_current_name (GtkFileChooserAction action, const char *path, const char *current_name, gboolean focus_button)
{
struct current_name_closure closure;
gboolean passed;
closure.path = path;
closure.current_name = current_name;
passed = test_set_filename (action, focus_button,
set_current_name_cb, compare_current_name_cb, &closure);
log_test (passed, "set_current_name, focus_button=%s", focus_button ? "TRUE" : "FALSE");
return passed;
}
/* https://bugzilla.novell.com/show_bug.cgi?id=184875
* http://bugzilla.gnome.org/show_bug.cgi?id=347066
* http://bugzilla.gnome.org/show_bug.cgi?id=346058
*/
static void
test_black_box (void)
{
gboolean passed;
char *cwd;
passed = TRUE;
passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_OPEN, FILE_NAME, FALSE);
g_assert (passed);
passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_OPEN, FILE_NAME, TRUE);
g_assert (passed);
passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_SAVE, FILE_NAME, FALSE);
g_assert (passed);
passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_SAVE, FILE_NAME, TRUE);
g_assert (passed);
passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, FOLDER_NAME, FALSE);
g_assert (passed);
passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, FOLDER_NAME, TRUE);
g_assert (passed);
passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, FOLDER_NAME, FALSE);
g_assert (passed);
passed = passed && test_black_box_set_filename (GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, FOLDER_NAME, TRUE);
g_assert (passed);
cwd = g_get_current_dir ();
passed = passed && test_black_box_set_current_name (GTK_FILE_CHOOSER_ACTION_SAVE, cwd, CURRENT_NAME, FALSE);
g_assert (passed);
passed = passed && test_black_box_set_current_name (GTK_FILE_CHOOSER_ACTION_SAVE, cwd, CURRENT_NAME, TRUE);
g_assert (passed);
passed = passed && test_black_box_set_current_name (GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, cwd, CURRENT_NAME_FOLDER, FALSE);
g_assert (passed);
passed = passed && test_black_box_set_current_name (GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, cwd, CURRENT_NAME_FOLDER, TRUE);
g_assert (passed);
g_free (cwd);
log_test (passed, "Black box tests");
}
int main (int argc, char ** argv)
{
int rank, size, i, j, k, token;
MPI_Comm comm = MPI_COMM_WORLD;
MPI_Status status;
enum ADIOS_READ_METHOD method = ADIOS_READ_METHOD_BP;
ADIOS_SELECTION * sel;
void * data = NULL;
uint64_t start[3], count[3], step = 0;
MPI_Init (&argc, &argv);
MPI_Comm_rank (comm, &rank);
MPI_Comm_size (comm, &size);
adios_read_init_method (method, comm, "verbose=3");
adios_logger_open ("log_read_as_file_C", rank);
/* adios_read_open_file() allows for seeing all timesteps in the file */
ADIOS_FILE * f = adios_read_open_file ("global_array_time_C.bp", method, comm);
if (f == NULL)
{
log_error ("%s\n", adios_errmsg());
return -1;
}
ADIOS_VARINFO * v = adios_inq_var (f, "temperature");
// read in two timesteps
data = malloc (2 * v->dims[0] * v->dims[1] * sizeof (double));
if (data == NULL)
{
log_error ("malloc failed.\n");
return -1;
}
// read in timestep 'rank' (up to 12)
step = rank % 13;
start[0] = 0;
count[0] = v->dims[0];
start[1] = 0;
count[1] = v->dims[1];
/* Read a subset of the temperature array */
sel = adios_selection_boundingbox (v->ndim, start, count);
/* 2 steps from 'step' */
adios_schedule_read (f, sel, "temperature", step, 2, data);
adios_perform_reads (f, 1);
if (rank == 0)
log_test ("Array size of temperature [0:%lld,0:%lld]\n", v->dims[0], v->dims[1]);
if (rank > 0) {
MPI_Recv (&token, 1, MPI_INT, rank-1, 0, comm, &status);
}
log_test("------------------------------------------------\n");
log_test("rank=%d: \n", rank);
for (i = 0; i < 2; i++) {
log_test ("step %lld = [\n", step+i);
for (j = 0; j < v->dims[0]; j++) {
log_test (" [");
for (k = 0; k < v->dims[1]; k++) {
log_test ("%g ", ((double *)data) [ i * v->dims[0] * v->dims[1] + j * v->dims[1] + k]);
}
log_test ("]\n");
}
log_test ("]\n");
}
log_test ("\n");
if (rank < size-1) {
MPI_Send (&token, 1, MPI_INT, rank+1, 0, comm);
}
free (data);
adios_free_varinfo (v);
adios_read_close (f);
MPI_Barrier (comm);
adios_read_finalize_method (method);
adios_logger_close();
MPI_Finalize ();
return 0;
}
int main (int argc, char ** argv)
{
int rank, size, i;
MPI_Comm comm = MPI_COMM_WORLD;
enum ADIOS_DATATYPES attr_type;
enum ADIOS_READ_METHOD method = ADIOS_READ_METHOD_BP;
int attr_size;
void * data = NULL;
MPI_Init (&argc, &argv);
MPI_Comm_rank (comm, &rank);
MPI_Comm_size (comm, &size);
adios_read_init_method (method, comm, "verbose=3");
adios_logger_open ("log_read_C", rank);
ADIOS_FILE * f = adios_read_open ("attributes_C.bp", method, comm, ADIOS_LOCKMODE_NONE, 0.0);
if (f == NULL)
{
log_error ("%s\n", adios_errmsg());
return -1;
}
for (i = 0; i < f->nattrs; i++)
{
adios_get_attr (f, f->attr_namelist[i], &attr_type, &attr_size, &data);
log_test("rank %d: attr: %s %s = ", rank, adios_type_to_string(attr_type), f->attr_namelist[i]);
int type_size = adios_type_size (attr_type, data);
int nelems = attr_size / type_size;
int k;
char *p = (char*)data;
for (k=0; k<nelems; k++)
{
if (k>0) log_test(", ");
switch (attr_type)
{
case adios_integer:
log_test ("%d", *(int *)p);
break;
case adios_double:
log_test ("%e", *(double *)p);
break;
case adios_string:
log_test ("\"%s\"", (char *)p);
break;
case adios_string_array:
log_test ("\"%s\"", *(char **)p);
break;
default:
log_test ("??????\n");
}
p=p+type_size;
}
log_test("\n");
free (data);
data = 0;
}
adios_read_close (f);
MPI_Barrier (comm);
adios_read_finalize_method (ADIOS_READ_METHOD_BP);
adios_logger_close();
MPI_Finalize ();
return 0;
}
static int32_t exec_test(char *path)
{
int32_t rtrn = 0;
pid_t exec_pid = 0;
char *buf auto_free = NULL;
char *args[] = { "blah", NULL };
/* Make sure path is not NULL, if it is return an error. */
if(path == NULL)
return (-1);
/* Create a child process. */
exec_pid = fork();
if(exec_pid == 0)
{
/* Set the PID of the currently running test. */
test_stat->running_test = getpid();
/* Execute the test passed, with no arguments. */
rtrn = execv(path, args);
if(rtrn < 0)
{
rtrn = asprintf(&buf, "%s failed", path);
if(rtrn < 0)
{
output(ERROR, "Can't create error string\n", strerror(errno));
return (-1);
}
log_test(FAIL, buf);
_exit(-1);
}
/* Exit and clean up the child process. */
_exit(0);
}
else if(exec_pid > 0)
{
int32_t status = 0;
/* Wait for the child (test case) process. */
wait4(exec_pid, &status, 0, NULL);
/* Make sure the process exited normally, if not return an error. */
if(WIFEXITED(status) != 0)
{
if(WEXITSTATUS(status) != 0)
{
rtrn = kill(test_stat->running_test, SIGKILL);
if(rtrn < 0)
{
output(ERROR, "Can't kill target process: %s\n", strerror(errno));
return (-1);
}
}
/* Return the exit status from the child process. */
return (WEXITSTATUS(status));
}
else
{
rtrn = asprintf(&buf, "%s failed", path);
if(rtrn < 0)
{
output(ERROR, "Can't create error string\n", strerror(errno));
return (-1);
}
log_test(FAIL, buf);
rtrn = kill(test_stat->running_test, SIGKILL);
if(rtrn < 0)
{
output(ERROR, "Can't kill target process: %s\n", strerror(errno));
return (-1);
}
return (-1);
}
}
else
{
output(ERROR, "Failed to fork reaper process: %s\n", strerror(errno));
return (-1);
}
}
/**************************************************************************
presult indicates if there is more packets in the cache. We return result
instead of just testing if the returning package is NULL as we sometimes
return a NULL packet even if everything is OK (receive_packet_goto_route).
**************************************************************************/
void *get_packet_from_connection(struct connection *pc,
enum packet_type *ptype, bool * presult)
{
int len_read;
int whole_packet_len;
struct {
enum packet_type type;
int itype;
} utype;
struct data_in din;
#ifdef USE_COMPRESSION
bool compressed_packet = FALSE;
int header_size = 0;
#endif
*presult = FALSE;
if (!pc->used) {
return NULL; /* connection was closed, stop reading */
}
if (pc->buffer->ndata < 3) {
return NULL; /* length and type not read */
}
dio_input_init(&din, pc->buffer->data, pc->buffer->ndata);
dio_get_uint16(&din, &len_read);
/* The non-compressed case */
whole_packet_len = len_read;
#ifdef USE_COMPRESSION
if (len_read == JUMBO_SIZE) {
compressed_packet = TRUE;
header_size = 6;
if (dio_input_remaining(&din) >= 4) {
dio_get_uint32(&din, &whole_packet_len);
log_compress("COMPRESS: got a jumbo packet of size %d",
whole_packet_len);
} else {
/* to return NULL below */
whole_packet_len = 6;
}
} else if (len_read >= COMPRESSION_BORDER) {
compressed_packet = TRUE;
header_size = 2;
whole_packet_len = len_read - COMPRESSION_BORDER;
log_compress("COMPRESS: got a normal packet of size %d",
whole_packet_len);
}
#endif
if ((unsigned)whole_packet_len > pc->buffer->ndata) {
return NULL; /* not all data has been read */
}
#ifdef USE_COMPRESSION
if (compressed_packet) {
uLong compressed_size = whole_packet_len - header_size;
/*
* We don't know the decompressed size. We assume a bad case
* here: an expansion by an factor of 100.
*/
unsigned long int decompressed_size = 100 * compressed_size;
void *decompressed = fc_malloc(decompressed_size);
int error;
struct socket_packet_buffer *buffer = pc->buffer;
error =
uncompress(decompressed, &decompressed_size,
ADD_TO_POINTER(buffer->data, header_size),
compressed_size);
if (error != Z_OK) {
log_verbose("Uncompressing of the packet stream failed. "
"The connection will be closed now.");
connection_close(pc, _("decoding error"));
return NULL;
}
buffer->ndata -= whole_packet_len;
/*
* Remove the packet with the compressed data and shift all the
* remaining data to the front.
*/
memmove(buffer->data, buffer->data + whole_packet_len, buffer->ndata);
if (buffer->ndata + decompressed_size > buffer->nsize) {
buffer->nsize += decompressed_size;
buffer->data = fc_realloc(buffer->data, buffer->nsize);
}
/*
* Make place for the uncompressed data by moving the remaining
* data.
*/
memmove(buffer->data + decompressed_size, buffer->data, buffer->ndata);
/*
* Copy the uncompressed data.
*/
memcpy(buffer->data, decompressed, decompressed_size);
free(decompressed);
buffer->ndata += decompressed_size;
log_compress("COMPRESS: decompressed %ld into %ld",
compressed_size, decompressed_size);
return get_packet_from_connection(pc, ptype, presult);
}
#endif
/*
* At this point the packet is a plain uncompressed one. These have
* to have to be at least 3 bytes in size.
*/
if (whole_packet_len < 3) {
log_verbose("The packet stream is corrupt. The connection "
"will be closed now.");
connection_close(pc, _("decoding error"));
return NULL;
}
dio_get_uint8(&din, &utype.itype);
utype.type = utype.itype;
log_packet("got packet type=(%s)%d len=%d from %s",
packet_name(utype.type), utype.itype, whole_packet_len,
is_server() ? pc->username : "******");
*ptype = utype.type;
*presult = TRUE;
if (pc->incoming_packet_notify) {
pc->incoming_packet_notify(pc, utype.type, whole_packet_len);
}
#if PACKET_SIZE_STATISTICS
{
static struct {
int counter;
int size;
} packets_stats[PACKET_LAST];
static int packet_counter = 0;
int packet_type = utype.itype;
int size = whole_packet_len;
if (!packet_counter) {
int i;
for (i = 0; i < PACKET_LAST; i++) {
packets_stats[i].counter = 0;
packets_stats[i].size = 0;
}
}
packets_stats[packet_type].counter++;
packets_stats[packet_type].size += size;
packet_counter++;
if (packet_counter % 100 == 0) {
int i, sum = 0;
log_test("Received packets:");
for (i = 0; i < PACKET_LAST; i++) {
if (packets_stats[i].counter == 0)
continue;
sum += packets_stats[i].size;
log_test(" [%-25.25s %3d]: %6d packets; %8d bytes total; "
"%5d bytes/packet average",
packet_name(i), i, packets_stats[i].counter,
packets_stats[i].size,
packets_stats[i].size / packets_stats[i].counter);
}
log_test("received %d bytes in %d packets;average size "
"per packet %d bytes",
sum, packet_counter, sum / packet_counter);
}
}
#endif
return get_packet_from_connection_helper(pc, utype.type);
}
/**************************************************************************
It returns the request id of the outgoing packet (or 0 if is_server()).
**************************************************************************/
int send_packet_data(struct connection *pc, unsigned char *data, int len)
{
/* default for the server */
int result = 0;
log_packet("sending packet type=%s(%d) len=%d to %s",
packet_name(data[2]), data[2], len,
is_server() ? pc->username : "******");
if (!is_server()) {
pc->client.last_request_id_used =
get_next_request_id(pc->client.last_request_id_used);
result = pc->client.last_request_id_used;
log_packet("sending request %d", result);
}
if (pc->outgoing_packet_notify) {
pc->outgoing_packet_notify(pc, data[2], len, result);
}
#ifdef USE_COMPRESSION
if (TRUE) {
int packet_type;
int size = len;
packet_type = data[2];
if (conn_compression_frozen(pc)) {
size_t old_size = pc->compression.queue.size;
byte_vector_reserve(&pc->compression.queue, old_size + len);
memcpy(pc->compression.queue.p + old_size, data, len);
log_compress2("COMPRESS: putting %s into the queue",
packet_name(packet_type));
if (MAX_LEN_BUFFER < byte_vector_size(&pc->compression.queue)) {
log_compress2("COMPRESS: huge queue, forcing to flush (%lu/%lu)",
(long unsigned)
byte_vector_size(&pc->compression.queue),
(long unsigned) MAX_LEN_BUFFER);
if (!conn_compression_flush(pc)) {
return -1;
}
byte_vector_reserve(&pc->compression.queue, 0);
}
} else {
stat_size_alone += size;
log_compress("COMPRESS: sending %s alone (%d bytes total)",
packet_name(packet_type), stat_size_alone);
connection_send_data(pc, data, len);
}
log_compress2("COMPRESS: STATS: alone=%d compression-expand=%d "
"compression (before/after) = %d/%d",
stat_size_alone, stat_size_no_compression,
stat_size_uncompressed, stat_size_compressed);
}
#else
connection_send_data(pc, data, len);
#endif
#if PACKET_SIZE_STATISTICS
{
static struct {
int counter;
int size;
} packets_stats[PACKET_LAST];
static int packet_counter = 0;
static int last_start_turn_seen = -1;
static bool start_turn_seen = FALSE;
int packet_type = data[2];
int size = len;
bool print = FALSE;
bool clear = FALSE;
if (!packet_counter) {
int i;
for (i = 0; i < PACKET_LAST; i++) {
packets_stats[i].counter = 0;
packets_stats[i].size = 0;
}
}
packets_stats[packet_type].counter++;
packets_stats[packet_type].size += size;
packet_counter++;
if (packet_type == PACKET_START_TURN
&& last_start_turn_seen != game.turn) {
start_turn_seen=TRUE;
last_start_turn_seen = game.turn;
}
if ((packet_type ==
PACKET_PROCESSING_FINISHED || packet_type == PACKET_THAW_HINT)
&& start_turn_seen) {
start_turn_seen = FALSE;
print = TRUE;
clear = TRUE;
}
if(print) {
int i, sum = 0;
#define log_ll log_debug
#if PACKET_SIZE_STATISTICS == 2
delta_stats_report();
#endif
log_ll("Transmitted packets:");
log_ll("%8s %8s %8s %s", "Packets", "Bytes", "Byt/Pac", "Name");
for (i = 0; i < PACKET_LAST; i++) {
if (packets_stats[i].counter == 0) {
continue;
}
sum += packets_stats[i].size;
log_ll("%8d %8d %8d %s(%i)",
packets_stats[i].counter, packets_stats[i].size,
packets_stats[i].size / packets_stats[i].counter,
packet_name(i),i);
}
log_test("turn=%d; transmitted %d bytes in %d packets;average size "
"per packet %d bytes", game.turn, sum, packet_counter,
sum / packet_counter);
log_test("turn=%d; transmitted %d bytes", game.turn,
pc->statistics.bytes_send);
}
if (clear) {
int i;
for (i = 0; i < PACKET_LAST; i++) {
packets_stats[i].counter = 0;
packets_stats[i].size = 0;
}
packet_counter = 0;
pc->statistics.bytes_send = 0;
delta_stats_reset();
}
}
#undef log_ll
#endif /* PACKET_SIZE_STATISTICS */
return result;
}
int main (int argc, char ** argv)
{
int rank, size, i, j;
MPI_Comm comm = MPI_COMM_WORLD;
enum ADIOS_READ_METHOD method = ADIOS_READ_METHOD_BP;
ADIOS_SELECTION * sel;
void * data = NULL;
uint64_t start[2], count[2];
MPI_Init (&argc, &argv);
MPI_Comm_rank (comm, &rank);
MPI_Comm_size (comm, &size);
adios_read_init_method (method, comm, "verbose=4");
adios_logger_open ("log_read_C", rank);
ADIOS_FILE * f = adios_read_open ("global_array_C.bp", method, comm, ADIOS_LOCKMODE_NONE, 0);
if (f == NULL)
{
log_error ("%s\n", adios_errmsg());
return -1;
}
ADIOS_VARINFO * v = adios_inq_var (f, "temperature");
/* Using less readers to read the global array back, i.e., non-uniform */
uint64_t slice_size = v->dims[0]/size;
start[0] = slice_size * rank;
if (rank == size-1) /* last rank may read more lines */
slice_size = slice_size + v->dims[0]%size;
count[0] = slice_size;
start[1] = 0;
count[1] = v->dims[1];
data = malloc (slice_size * v->dims[1] * sizeof (double));
if (data == NULL)
{
log_error (stderr, "malloc failed.\n");
return -1;
}
/* Read a subset of the temperature array */
sel = adios_selection_boundingbox (v->ndim, start, count);
adios_schedule_read (f, sel, "temperature", 0, 1, data);
adios_perform_reads (f, 1);
for (i = 0; i < slice_size; i++) {
log_test ("rank %d: [%lld,%d:%lld]", rank, start[0]+i, 0, slice_size);
for (j = 0; j < v->dims[1]; j++)
log_test (" %6.6g", * ((double *)data + i * v->dims[1] + j));
log_test ("\n");
}
free (data);
adios_read_close (f);
MPI_Barrier (comm);
adios_read_finalize_method (method);
adios_logger_close();
MPI_Finalize ();
return 0;
}
/**************************************************************************
It returns the request id of the outgoing packet (or 0 if is_server()).
**************************************************************************/
int send_packet_data(struct connection *pc, unsigned char *data, int len,
enum packet_type packet_type)
{
/* default for the server */
int result = 0;
log_packet("sending packet type=%s(%d) len=%d to %s",
packet_name(packet_type), packet_type, len,
is_server() ? pc->username : "******");
if (!is_server()) {
pc->client.last_request_id_used =
get_next_request_id(pc->client.last_request_id_used);
result = pc->client.last_request_id_used;
log_packet("sending request %d", result);
}
if (pc->outgoing_packet_notify) {
pc->outgoing_packet_notify(pc, packet_type, len, result);
}
#ifdef USE_COMPRESSION
if (TRUE) {
int size = len;
if (conn_compression_frozen(pc)) {
size_t old_size;
/* Keep this a decent amount less than MAX_LEN_BUFFER to avoid the
* (remote) possibility of trying to dump MAX_LEN_BUFFER to the
* network in one go */
#define MAX_LEN_COMPRESS_QUEUE (MAX_LEN_BUFFER/2)
FC_STATIC_ASSERT(MAX_LEN_COMPRESS_QUEUE < MAX_LEN_BUFFER,
compress_queue_maxlen_too_big);
/* If this packet would cause us to overfill the queue, flush
* everything that's in there already before queuing this one */
if (MAX_LEN_COMPRESS_QUEUE
< byte_vector_size(&pc->compression.queue) + len) {
log_compress2("COMPRESS: huge queue, forcing to flush (%lu/%lu)",
(long unsigned)
byte_vector_size(&pc->compression.queue),
(long unsigned) MAX_LEN_COMPRESS_QUEUE);
if (!conn_compression_flush(pc)) {
return -1;
}
byte_vector_reserve(&pc->compression.queue, 0);
}
old_size = byte_vector_size(&pc->compression.queue);
byte_vector_reserve(&pc->compression.queue, old_size + len);
memcpy(pc->compression.queue.p + old_size, data, len);
log_compress2("COMPRESS: putting %s into the queue",
packet_name(packet_type));
} else {
stat_size_alone += size;
log_compress("COMPRESS: sending %s alone (%d bytes total)",
packet_name(packet_type), stat_size_alone);
connection_send_data(pc, data, len);
}
log_compress2("COMPRESS: STATS: alone=%d compression-expand=%d "
"compression (before/after) = %d/%d",
stat_size_alone, stat_size_no_compression,
stat_size_uncompressed, stat_size_compressed);
}
#else /* USE_COMPRESSION */
connection_send_data(pc, data, len);
#endif /* USE_COMPRESSION */
#if PACKET_SIZE_STATISTICS
{
static struct {
int counter;
int size;
} packets_stats[PACKET_LAST];
static int packet_counter = 0;
static int last_start_turn_seen = -1;
static bool start_turn_seen = FALSE;
int size = len;
bool print = FALSE;
bool clear = FALSE;
if (!packet_counter) {
int i;
for (i = 0; i < PACKET_LAST; i++) {
packets_stats[i].counter = 0;
packets_stats[i].size = 0;
}
}
packets_stats[packet_type].counter++;
packets_stats[packet_type].size += size;
packet_counter++;
if (packet_type == PACKET_START_TURN
&& last_start_turn_seen != game.turn) {
start_turn_seen=TRUE;
last_start_turn_seen = game.turn;
}
if ((packet_type ==
PACKET_PROCESSING_FINISHED || packet_type == PACKET_THAW_HINT)
&& start_turn_seen) {
start_turn_seen = FALSE;
print = TRUE;
clear = TRUE;
}
if(print) {
int i, sum = 0;
#define log_ll log_debug
#if PACKET_SIZE_STATISTICS == 2
delta_stats_report();
#endif
log_ll("Transmitted packets:");
log_ll("%8s %8s %8s %s", "Packets", "Bytes", "Byt/Pac", "Name");
for (i = 0; i < PACKET_LAST; i++) {
if (packets_stats[i].counter == 0) {
continue;
}
sum += packets_stats[i].size;
log_ll("%8d %8d %8d %s(%i)",
packets_stats[i].counter, packets_stats[i].size,
packets_stats[i].size / packets_stats[i].counter,
packet_name(i),i);
}
log_test("turn=%d; transmitted %d bytes in %d packets;average size "
"per packet %d bytes", game.turn, sum, packet_counter,
sum / packet_counter);
log_test("turn=%d; transmitted %d bytes", game.turn,
pc->statistics.bytes_send);
}
if (clear) {
int i;
for (i = 0; i < PACKET_LAST; i++) {
packets_stats[i].counter = 0;
packets_stats[i].size = 0;
}
packet_counter = 0;
pc->statistics.bytes_send = 0;
delta_stats_reset();
}
}
#undef log_ll
#endif /* PACKET_SIZE_STATISTICS */
return result;
}
/* http://bugzilla.gnome.org/show_bug.cgi?id=347883 */
static gboolean
test_confirm_overwrite_for_path (const char *path, gboolean append_extension)
{
gboolean passed;
struct confirm_overwrite_closure closure;
char *filename;
passed = TRUE;
closure.extension = NULL;
closure.confirm_overwrite_signal_emitted = 0;
closure.chooser = gtk_file_chooser_dialog_new ("hello", NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
closure.accept_button = gtk_dialog_add_button (GTK_DIALOG (closure.chooser),
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT);
gtk_dialog_set_default_response (GTK_DIALOG (closure.chooser), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (closure.chooser), TRUE);
g_signal_connect (closure.chooser, "confirm-overwrite",
G_CALLBACK (confirm_overwrite_cb), &closure);
if (append_extension)
{
char *extension;
filename = g_path_get_dirname (path);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (closure.chooser), filename);
g_free (filename);
filename = g_path_get_basename (path);
extension = strchr (filename, '.');
if (extension)
{
closure.extension = g_strdup (extension);
*extension = '\0';
}
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (closure.chooser), filename);
g_free (filename);
g_signal_connect (closure.chooser, "response",
G_CALLBACK (overwrite_response_cb), &closure);
}
else
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (closure.chooser), path);
}
gdk_threads_add_timeout_full (G_MAXINT, SLEEP_DURATION, confirm_overwrite_timeout_cb, &closure, NULL);
gtk_dialog_run (GTK_DIALOG (closure.chooser));
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (closure.chooser));
passed = passed && filename && (strcmp (filename, path) == 0);
g_free (filename);
gtk_widget_destroy (closure.chooser);
passed = passed && (1 == closure.confirm_overwrite_signal_emitted);
log_test (passed, "Confirm overwrite for %s", path);
return passed;
}
static void
test_folder_switch_and_filters (void)
{
gboolean passed;
char *cwd;
char *base_dir;
GtkFilePath *cwd_path;
GtkFilePath *base_dir_path;
GtkWidget *dialog;
GtkFileFilter *all_filter;
GtkFileFilter *txt_filter;
GtkFileChooserDefault *impl;
passed = TRUE;
cwd = g_get_current_dir ();
base_dir = g_build_filename (cwd, "file-chooser-test-dir", NULL);
dialog = gtk_file_chooser_dialog_new ("Test", NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
impl = get_impl_from_dialog (dialog);
cwd_path = gtk_file_system_filename_to_path (impl->file_system, cwd);
base_dir_path = gtk_file_system_filename_to_path (impl->file_system, base_dir);
passed = passed && gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), base_dir);
g_assert (passed);
/* All files filter */
all_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (all_filter, "All files");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), all_filter);
/* *.txt filter */
txt_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (all_filter, "*.txt");
gtk_file_filter_add_pattern (txt_filter, "*.txt");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), txt_filter);
/* Test filter set */
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), all_filter);
passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == all_filter);
g_assert (passed);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), txt_filter);
passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter);
log_test (passed, "test_folder_switch_and_filters(): set and get filter");
g_assert (passed);
gtk_widget_show (dialog);
/* Test that filter is unchanged when we switch folders */
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), cwd);
sleep_in_main_loop (0.5);
passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter);
g_assert (passed);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), base_dir);
sleep_in_main_loop (0.25);
g_signal_emit_by_name (impl->browse_path_bar, "path-clicked",
(GtkFilePath *) cwd_path,
(GtkFilePath *) base_dir_path,
FALSE);
sleep_in_main_loop (0.25);
passed = passed && (gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)) == txt_filter);
log_test (passed, "test_folder_switch_and_filters(): filter after changing folder");
g_assert (passed);
/* cleanups */
g_free (cwd);
g_free (base_dir);
gtk_file_path_free (cwd_path);
gtk_file_path_free (base_dir_path);
gtk_widget_destroy (dialog);
log_test (passed, "test_folder_switch_and_filters(): all filter tests");
}
static gboolean
test_reload_sequence (gboolean set_folder_before_map)
{
GtkWidget *dialog;
GtkFileChooserDefault *impl;
gboolean passed;
char *folder;
char *current_working_dir;
passed = TRUE;
current_working_dir = g_get_current_dir ();
dialog = gtk_file_chooser_dialog_new ("Test file chooser",
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
impl = get_impl_from_dialog (dialog);
if (set_folder_before_map)
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_get_home_dir ());
wait_for_idle ();
passed = passed && (impl->current_folder != NULL
&& impl->browse_files_model != NULL
&& (impl->load_state == LOAD_PRELOAD || impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
&& impl->reload_state == RELOAD_HAS_FOLDER
&& (impl->load_state == LOAD_PRELOAD ? (impl->load_timeout_id != 0) : TRUE)
&& ((impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
? (impl->load_timeout_id == 0 && impl->sort_model != NULL)
: TRUE));
wait_for_idle ();
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
passed = passed && (g_strcmp0 (folder, g_get_home_dir()) == 0);
g_free (folder);
}
else
{
/* Initially, no folder is not loaded or pending */
passed = passed && (impl->current_folder == NULL
&& impl->sort_model == NULL
&& impl->browse_files_model == NULL
&& impl->load_state == LOAD_EMPTY
&& impl->reload_state == RELOAD_EMPTY
&& impl->load_timeout_id == 0);
wait_for_idle ();
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
passed = passed && (g_strcmp0 (folder, current_working_dir) == 0);
}
log_test (passed, "test_reload_sequence(): initial status");
/* After mapping, it is loading some folder, either the one that was explicitly set or the default one */
gtk_widget_show_now (dialog);
wait_for_idle ();
passed = passed && (impl->current_folder != NULL
&& impl->browse_files_model != NULL
&& (impl->load_state == LOAD_PRELOAD || impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
&& impl->reload_state == RELOAD_HAS_FOLDER
&& (impl->load_state == LOAD_PRELOAD ? (impl->load_timeout_id != 0) : TRUE)
&& ((impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
? (impl->load_timeout_id == 0 && impl->sort_model != NULL)
: TRUE));
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (set_folder_before_map)
passed = passed && (g_strcmp0 (folder, g_get_home_dir()) == 0);
else
passed = passed && (g_strcmp0 (folder, current_working_dir) == 0);
g_free (folder);
log_test (passed, "test_reload_sequence(): status after map");
/* Unmap it; we should still have a folder */
gtk_widget_hide (dialog);
wait_for_idle ();
passed = passed && (impl->current_folder != NULL
&& impl->browse_files_model != NULL
&& (impl->load_state == LOAD_PRELOAD || impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
&& (impl->load_state == LOAD_PRELOAD ? (impl->load_timeout_id != 0) : TRUE)
&& ((impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
? (impl->load_timeout_id == 0 && impl->sort_model != NULL)
: TRUE));
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (set_folder_before_map)
passed = passed && (g_strcmp0 (folder, g_get_home_dir()) == 0);
else
passed = passed && (g_strcmp0 (folder, current_working_dir) == 0);
g_free (folder);
log_test (passed, "test_reload_sequence(): status after unmap");
/* Map it again! */
gtk_widget_show_now (dialog);
wait_for_idle ();
passed = passed && (impl->current_folder != NULL
&& impl->browse_files_model != NULL
&& (impl->load_state == LOAD_PRELOAD || impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
&& impl->reload_state == RELOAD_HAS_FOLDER
&& (impl->load_state == LOAD_PRELOAD ? (impl->load_timeout_id != 0) : TRUE)
&& ((impl->load_state == LOAD_LOADING || impl->load_state == LOAD_FINISHED)
? (impl->load_timeout_id == 0 && impl->sort_model != NULL)
: TRUE));
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (set_folder_before_map)
passed = passed && (g_strcmp0 (folder, g_get_home_dir()) == 0);
else
passed = passed && (g_strcmp0 (folder, current_working_dir) == 0);
g_free (folder);
log_test (passed, "test_reload_sequence(): status after re-map");
gtk_widget_destroy (dialog);
g_free (current_working_dir);
return passed;
}
static gboolean
test_button_folder_states_for_action (GtkFileChooserAction action, gboolean use_dialog, gboolean set_folder_on_dialog)
{
gboolean passed;
GtkWidget *window;
GtkWidget *button;
char *folder;
GtkWidget *dialog;
char *current_working_dir;
gboolean must_have_cwd;
passed = TRUE;
current_working_dir = g_get_current_dir ();
must_have_cwd = !(use_dialog && set_folder_on_dialog);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (use_dialog)
{
dialog = gtk_file_chooser_dialog_new ("Test", NULL, action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
button = gtk_file_chooser_button_new_with_dialog (dialog);
if (set_folder_on_dialog)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_get_home_dir ());
}
else
{
button = gtk_file_chooser_button_new ("Test", action);
dialog = NULL; /* keep gcc happy */
}
gtk_container_add (GTK_CONTAINER (window), button);
/* Pre-map; no folder is set */
wait_for_idle ();
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (button));
if (must_have_cwd)
passed = passed && (g_strcmp0 (folder, current_working_dir) == 0);
else
passed = passed && (g_strcmp0 (folder, g_get_home_dir()) == 0);
log_test (passed, "test_button_folder_states_for_action(): %s, use_dialog=%d, set_folder_on_dialog=%d, pre-map, %s",
get_action_name (action),
use_dialog,
set_folder_on_dialog,
must_have_cwd ? "must have $cwd" : "must have explicit folder");
/* Map; folder should be set */
gtk_widget_show_all (window);
gtk_widget_show_now (window);
wait_for_idle ();
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (button));
if (must_have_cwd)
passed = passed && (g_strcmp0 (folder, current_working_dir) == 0);
else
passed = passed && (g_strcmp0 (folder, g_get_home_dir()) == 0);
log_test (passed, "test_button_folder_states_for_action(): %s, use_dialog=%d, set_folder_on_dialog=%d, mapped, %s",
get_action_name (action),
use_dialog,
set_folder_on_dialog,
must_have_cwd ? "must have $cwd" : "must have explicit folder");
g_free (folder);
/* Unmap; folder should be set */
gtk_widget_hide (window);
wait_for_idle ();
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (button));
if (must_have_cwd)
passed = passed && (g_strcmp0 (folder, current_working_dir) == 0);
else
passed = passed && (g_strcmp0 (folder, g_get_home_dir()) == 0);
log_test (passed, "test_button_folder_states_for_action(): %s, use_dialog=%d, set_folder_on_dialog=%d, unmapped, %s",
get_action_name (action),
use_dialog,
set_folder_on_dialog,
must_have_cwd ? "must have $cwd" : "must have explicit folder");
g_free (folder);
/* Re-map; folder should be set */
gtk_widget_show_now (window);
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (button));
if (must_have_cwd)
passed = passed && (g_strcmp0 (folder, current_working_dir) == 0);
else
passed = passed && (g_strcmp0 (folder, g_get_home_dir()) == 0);
wait_for_idle ();
log_test (passed, "test_button_folder_states_for_action(): %s, use_dialog=%d, set_folder_on_dialog=%d, re-mapped, %s",
get_action_name (action),
use_dialog,
set_folder_on_dialog,
must_have_cwd ? "must have $cwd" : "must have explicit folder");
g_free (folder);
g_free (current_working_dir);
gtk_widget_destroy (window);
return passed;
}
