void card_test( int *passed, int *failed )
{
plugin_log *log = plugin_log_create();
if ( log != NULL )
{
int res = make_test_data(log);
if ( res )
{
orphanage *o = orphanage_create();
card_test_links( passed, failed, log );
card_test_replace( passed, failed, log );
card_test_text_off( passed, failed, log );
card_test_trailing( passed, failed, log );
card_test_next( passed, failed, log );
card_test_split( passed, failed, o, log );
card_test_array( passed, failed, log );
card_test_node_to_right( passed, failed, log );
card_test_node_to_left( passed, failed, log );
card_test_overhang( passed, failed, log );
card_test_add_at_node( passed, failed, log );
card_test_add_after( passed, failed, log );
card_test_list_len( passed, failed, log );
card_test_circular( passed, failed, log );
card_test_remove( passed, failed, log );
}
else
{
fprintf(stderr,"card: failed to initialise test data\n");
(*failed)++;
}
}
else
(*failed)++;
free_test_data(log);
}
static void
execute_search_test (const gchar *test_id)
{
GrlSource *source;
GrlMedia *media;
GrlOperationOptions *options;
GList *keys, *list_medias;
set_test_data (&source, &media, &options, &keys, GRL_OP_RESOLVE);
list_medias = grl_source_search_sync (source, test_id, keys, options, NULL);
g_list_free_full (list_medias, g_object_unref);
free_test_data (&media, &options, &keys);
}
static void
execute_resolve_test (const gchar *test_id)
{
GrlSource *source;
GrlMedia *media;
GrlOperationOptions *options;
GList *keys;
set_test_data (&source, &media, &options, &keys, GRL_OP_RESOLVE);
grl_media_set_id (media, test_id);
grl_source_resolve_sync (source, media, keys, options, NULL);
free_test_data (&media, &options, &keys);
}
void process_test_stream(void)
{
int forever = TRUE;
char *callsign;
double lat, lon, alt;
date_time_t wall_time;
time_t last_store = 0;
init_test_data();
while (forever) {
PMU_auto_register("Got data");
get_test_data(&callsign, &lat, &lon, &alt);
/*
* substitute wall clock time for gps time
*/
wall_time.unix_time = time(NULL);
uconvert_from_utime(&wall_time);
if((wall_time.unix_time - last_store) >= Glob->params.data_interval) {
store_line(&wall_time, lat, lon, alt, callsign,
0.0, 0.0, 0.0, 0.0, 0, 0, 0, 0);
if (Glob->params.use_spdb) {
if (Glob->params.single_database) {
store_single_spdb(&wall_time, lat, lon, alt, callsign);
} else {
store_mult_spdb(&wall_time, lat, lon, alt, callsign);
}
} /* if (Glob->params.use_spdb) */
last_store = wall_time.unix_time;
} /* if((wall_time.unix_time - last_store) ... */
sleep(1);
} /* while (forever) */
free_test_data();
}
static void test_acpi_asl(test_data *data)
{
int i;
AcpiSdtTable *sdt, *exp_sdt;
test_data exp_data;
gboolean exp_err, err;
memset(&exp_data, 0, sizeof(exp_data));
exp_data.tables = load_expected_aml(data);
dump_aml_files(data, false);
for (i = 0; i < data->tables->len; ++i) {
GString *asl, *exp_asl;
sdt = &g_array_index(data->tables, AcpiSdtTable, i);
exp_sdt = &g_array_index(exp_data.tables, AcpiSdtTable, i);
err = load_asl(data->tables, sdt);
asl = normalize_asl(sdt->asl);
exp_err = load_asl(exp_data.tables, exp_sdt);
exp_asl = normalize_asl(exp_sdt->asl);
/* TODO: check for warnings */
g_assert(!err || exp_err);
if (g_strcmp0(asl->str, exp_asl->str)) {
if (exp_err) {
fprintf(stderr,
"Warning! iasl couldn't parse the expected aml\n");
} else {
uint32_t signature = cpu_to_le32(exp_sdt->header.signature);
sdt->tmp_files_retain = true;
exp_sdt->tmp_files_retain = true;
fprintf(stderr,
"acpi-test: Warning! %.4s mismatch. "
"Actual [asl:%s, aml:%s], Expected [asl:%s, aml:%s].\n",
(gchar *)&signature,
sdt->asl_file, sdt->aml_file,
exp_sdt->asl_file, exp_sdt->aml_file);
}
}
g_string_free(asl, true);
g_string_free(exp_asl, true);
}
free_test_data(&exp_data);
}
static void test_acpi_asl(test_data *data)
{
int i;
AcpiSdtTable *sdt, *exp_sdt;
test_data exp_data;
gboolean exp_err, err;
memset(&exp_data, 0, sizeof(exp_data));
exp_data.tables = load_expected_aml(data);
dump_aml_files(data, false);
for (i = 0; i < data->tables->len; ++i) {
GString *asl, *exp_asl;
sdt = &g_array_index(data->tables, AcpiSdtTable, i);
exp_sdt = &g_array_index(exp_data.tables, AcpiSdtTable, i);
err = load_asl(data->tables, sdt);
asl = normalize_asl(sdt->asl);
exp_err = load_asl(exp_data.tables, exp_sdt);
exp_asl = normalize_asl(exp_sdt->asl);
/* TODO: check for warnings */
g_assert(!err || exp_err);
if (g_strcmp0(asl->str, exp_asl->str)) {
if (exp_err) {
fprintf(stderr,
"Warning! iasl couldn't parse the expected aml\n");
} else {
uint32_t signature = cpu_to_le32(exp_sdt->header.signature);
sdt->tmp_files_retain = true;
exp_sdt->tmp_files_retain = true;
fprintf(stderr,
"acpi-test: Warning! %.4s mismatch. "
"Actual [asl:%s, aml:%s], Expected [asl:%s, aml:%s].\n",
(gchar *)&signature,
sdt->asl_file, sdt->aml_file,
exp_sdt->asl_file, exp_sdt->aml_file);
if (getenv("V")) {
const char *diff_cmd = getenv("DIFF");
if (diff_cmd) {
int ret G_GNUC_UNUSED;
char *diff = g_strdup_printf("%s %s %s", diff_cmd,
exp_sdt->asl_file, sdt->asl_file);
ret = system(diff) ;
g_free(diff);
} else {
fprintf(stderr, "acpi-test: Warning. not showing "
"difference since no diff utility is specified. "
"Set 'DIFF' environment variable to a preferred "
"diff utility and run 'make V=1 check' again to "
"see ASL difference.");
}
}
}
}
g_string_free(asl, true);
g_string_free(exp_asl, true);
}
free_test_data(&exp_data);
}
/*
* Test main function
*/
int test_noise(Test_time_result_type *times, int mes_length, int num_repeats, int num_noise_repeats, int loading, int num_noise_procs )
{
int* mode_array=NULL;
init_test_data( &td );
int proc1, proc2;
MPI_Status status;
MPI_Request send_request;
MPI_Request recv_request;
MPI_Request* requests_noise=NULL;
MPI_Status* statuses_noise=NULL;
int sync_sum;
int i, j, k, l;
px_my_time_type time_beg,time_end;
px_my_time_type sum;
px_my_time_type st_deviation;
int flag;
int work_flag=1;
int command[2];
int remote_proc;
/*
* Try get enough memory. If didn't, return -1. In send_request we got memory for both send and receive request
*/
requests_noise=(MPI_Request *)malloc(2*num_noise_procs*sizeof(MPI_Request));
if(requests_noise == NULL )
{
return -1;
}
statuses_noise=(MPI_Status *)malloc(2*num_noise_procs*sizeof(MPI_Status));
if(statuses_noise == NULL )
{
return -1;
}
mode_array=(int *)malloc(comm_size*sizeof(int));
if(mode_array==NULL)
{
return -1;
}
if ( !alloc_test_data( &td, mes_length, num_repeats, loading, num_noise_procs ) )
{
return -1;
}
/*
* Ok, lets begin test part
*/
srand( (unsigned)time( NULL ) );
for(i=0; i<comm_size; i++)
for(j=0; j<num_repeats; j++)
{
td.tmp_results[i][j] = 0;
}
if(comm_rank==0)
{
/* Uncomment to debug
printf("HELLO! I'm 0, press any key\n");
getchar();
*/
for(proc1=0;proc1<comm_size; proc1++)
for(proc2=0;proc2<comm_size; proc2++)
{
flag=init_mode_array(proc1,proc2,num_noise_procs,comm_size,mode_array);
if(flag)
{
return -1;
}
for(i=0;i<num_repeats;i++)
{
MPI_Bcast( mode_array, comm_size, MPI_INT, 0, MPI_COMM_WORLD );
command[0]=i; /* Iteration number */
command[1]=proc2; /* Leader (messages passing durations will be stored) */
if(proc1!=0)
{
MPI_Send(&command,2,MPI_INT,proc1,1,MPI_COMM_WORLD);
}
if((proc2!=0)&&(proc2!=proc1))
{
MPI_Send(&command,2,MPI_INT,proc2,1,MPI_COMM_WORLD);
}
/*
*
* Goal messages in proc with number 0
*
*/
if(mode_array[0]==MODE_GOAL_MESSAGES)
{
if(proc1==0)
{
remote_proc=proc2;
}
else
{
remote_proc=proc1;
}
time_beg=px_my_cpu_time();
MPI_Isend( td.send_data[remote_proc], mes_length, MPI_BYTE, remote_proc, 0, MPI_COMM_WORLD, &send_request);
MPI_Irecv( td.recv_data[remote_proc], mes_length, MPI_BYTE, remote_proc, 0, MPI_COMM_WORLD, &recv_request);
MPI_Wait( &send_request, &status );
MPI_Wait( &recv_request, &status );
time_end = px_my_cpu_time();
/*
*
* command[0] -- current interation number in message passing repeats
* command[1] -- process leader in the pair
*
*/
if(proc2==0)
{
td.tmp_results[proc1][i] = (px_my_time_type)(time_end - time_beg);
}
}
/*
*
* Noise messages in proc with number 0
*
*/
if(mode_array[0]==MODE_NOISE_MESSAGES)
{
for( j = 0; j < num_noise_repeats; j++ )
{
k=0;
for( l = 1; l < comm_size; l++ )
{
if( mode_array[l]==MODE_NOISE_MESSAGES )
{
MPI_Isend( td.send_data_noise[l], loading, MPI_BYTE, l, 0, MPI_COMM_WORLD, &requests_noise[k] );
MPI_Irecv( td.recv_data_noise[l], loading, MPI_BYTE, l, 0, MPI_COMM_WORLD, &requests_noise[k+1]);
k+=2;
}
}
MPI_Waitall(k,requests_noise,statuses_noise);
}
}
/*
*
* This reduce is used for processes syncronization. All must send
* their order number to the process with number 0
*
*/
MPI_Reduce(&comm_rank,&sync_sum,1,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD);
} /* end for (num_repeats) */
} /* End for proc1,proc2 */
/*
*
* Finishing work
*
*/
for(i=0;i<comm_size;i++)
{
mode_array[i]=MODE_FINISH_WORK;
}
MPI_Bcast( mode_array, comm_size, MPI_INT, 0, MPI_COMM_WORLD );
MPI_Reduce(&comm_rank,&sync_sum,1,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD);
} /* end if(comm_rank==0) */
else
{
while(work_flag)
{
MPI_Bcast( mode_array, comm_size, MPI_INT, 0, MPI_COMM_WORLD );
switch(mode_array[comm_rank])
{
case MODE_GOAL_MESSAGES:
MPI_Recv(&command,2,MPI_INT,0,1,MPI_COMM_WORLD,&status);
remote_proc=comm_rank;
for(i=0;i<comm_size;i++)
{
if((mode_array[i]==MODE_GOAL_MESSAGES)&&(i!=comm_rank))
{
remote_proc=i;
break;
}
}
time_beg=px_my_cpu_time();
MPI_Isend( td.send_data[remote_proc], mes_length, MPI_BYTE, remote_proc, 0, MPI_COMM_WORLD, &send_request);
MPI_Irecv( td.recv_data[remote_proc], mes_length, MPI_BYTE, remote_proc, 0, MPI_COMM_WORLD, &recv_request);
MPI_Wait( &send_request, &status );
MPI_Wait( &recv_request, &status );
time_end = px_my_cpu_time();
/*
*
* command[0] -- current interation number in message passing repeats
* command[1] -- process leader in the pair
*
*/
if(comm_rank==command[1])
{
td.tmp_results[remote_proc][command[0]] = (px_my_time_type)(time_end - time_beg);
}
break;
case MODE_NOISE_MESSAGES:
for( i = 0; i < num_noise_repeats; i++ )
{
k=0;
for( j = 0; j < comm_size; j++ )
{
if( (j != comm_rank) && (mode_array[j] == MODE_NOISE_MESSAGES ) )
{
MPI_Isend( td.send_data_noise[j], loading, MPI_BYTE, j, 0, MPI_COMM_WORLD, &requests_noise[k] );
MPI_Irecv( td.recv_data_noise[j], loading, MPI_BYTE, j, 0, MPI_COMM_WORLD, &requests_noise[k+1]);
k+=2;
}
}
MPI_Waitall(k,requests_noise,statuses_noise);
}
break;
case MODE_FINISH_WORK:
work_flag=0;
break;
}
MPI_Reduce(&comm_rank,&sync_sum,1,MPI_INT,MPI_SUM,0,MPI_COMM_WORLD);
} /* end while work_flag */
} /* end else if(comm_rank==0) */
/*
* Averaging results
*/
for( i = 0; i < comm_size; i++ )
{
sum = 0;
for( j = 0; j < num_repeats; j++ )
{
sum += td.tmp_results[i][j];
}
times[i].average=(sum/(double)num_repeats);
st_deviation=0;
for(j=0;j<num_repeats;j++)
{
st_deviation+=(td.tmp_results[i][j]-times[i].average)*(td.tmp_results[i][j]-times[i].average);
}
st_deviation/=(double)(num_repeats);
times[i].deviation=sqrt(st_deviation);
/*
*
* Function my_time_cmp is described in the file 'network_test.h' and
* is implemented in the file 'network_test.cpp'.
*
*/
qsort(td.tmp_results[i], num_repeats, sizeof(px_my_time_type), my_time_cmp );
times[i].median=td.tmp_results[i][num_repeats/2];
times[i].min=td.tmp_results[i][0];
}
/*
* Free memory
*/
free( requests_noise );
free( statuses_noise );
free( mode_array );
free_test_data( &td );
return 0;
}
