static void
std_set_string_attr(attr_list l, char *name, char *value)
{
atom_t atom = attr_atom_from_string(name);
if (atom == 0 ) return;
set_string_attr(l, atom, value);
}
static uint64_t
calc_ffspacket_size(FMField *f, attr_list attrs, void *buffer)
{
uint64_t size = 0;
while(f->field_name){
char atom_name[200] = "";
strcat(atom_name, FP_NDIMS_ATTR_NAME);
strcat(atom_name, "_");
strcat(atom_name, f->field_name);
int num_dims = 0;
get_int_attr(attrs, attr_atom_from_string(atom_name), &num_dims);
if(num_dims == 0){
size += (uint64_t)f->field_size;
}
else{
int i;
uint64_t tmpsize = (uint64_t)f->field_size;
for(i=0; i<num_dims; i++){
char *dim;
char atom_name[200] ="";
strcat(atom_name, FP_DIM_ATTR_NAME);
strcat(atom_name, "_");
strcat(atom_name, f->field_name);
strcat(atom_name, "_");
char dim_num[10] = "";
sprintf(dim_num, "%d", i+1);
strcat(atom_name, dim_num);
get_string_attr(attrs, attr_atom_from_string(atom_name), &dim);
FMField *temp_field = find_field_by_name(dim, f);
uint64_t *temp_val = get_FMfieldAddr_by_name(temp_field,
temp_field->field_name,
buffer);
uint64_t dimval = *temp_val;
tmpsize *= dimval;
}
size += tmpsize;
}
f++;
}
return size;
}
static int
attr_set(attr_list l, char *name)
{
atom_t atom = attr_atom_from_string(name);
attr_value_type junk;
attr_value junk2;
if (atom == 0 ) return 0;
return query_attr(l, atom, &junk, &junk2);
}
static char *
attr_svalue(attr_list l, char *name)
{
atom_t atom = attr_atom_from_string(name);
char *s;
if (atom == 0 ) return 0;
get_string_attr(l, atom, &s);
return strdup(s);
}
static float
attr_fvalue(attr_list l, char *name)
{
atom_t atom = attr_atom_from_string(name);
float f;
if (atom == 0 ) return 0;
get_float_attr(l, atom, &f);
return f;
}
static double
attr_dvalue(attr_list l, char *name)
{
atom_t atom = attr_atom_from_string(name);
double d;
if (atom == 0 ) return 0;
get_double_attr(l, atom, &d);
return d;
}
static long
attr_lvalue(attr_list l, char *name)
{
atom_t atom = attr_atom_from_string(name);
long lo = 0;
if (atom == 0 ) return 0;
get_long_attr(l, atom, &lo);
return lo;
}
static int
attr_ivalue(attr_list l, char *name)
{
atom_t atom = attr_atom_from_string(name);
int i = 0;
if (atom == 0 ) return 0;
get_int_attr(l, atom, &i);
return i;
}
int
get_ndims_attr(const char *field_name, attr_list attrs)
{
char atom_name[200] = "";
strcat(atom_name, FP_NDIMS_ATTR_NAME);
strcat(atom_name, "_");
strcat(atom_name, field_name);
int num_dims;
atom_t atm = attr_atom_from_string(atom_name);
get_int_attr(attrs, atm, &num_dims);
return num_dims;
}
/*
* Gathers basic MPI information; sets up reader CM.
*/
int
adios_read_flexpath_init_method (MPI_Comm comm, PairStruct* params)
{
setenv("CMSelfFormats", "1", 1);
fp_read_data = malloc(sizeof(flexpath_read_data));
if(!fp_read_data) {
adios_error(err_no_memory, "Cannot allocate memory for flexpath.");
return -1;
}
memset(fp_read_data, 0, sizeof(flexpath_read_data));
fp_read_data->CM_TRANSPORT = attr_atom_from_string("CM_TRANSPORT");
attr_list listen_list = NULL;
char * transport = NULL;
transport = getenv("CMTransport");
// setup MPI stuffs
fp_read_data->fp_comm = comm;
MPI_Comm_size(fp_read_data->fp_comm, &(fp_read_data->fp_comm_size));
MPI_Comm_rank(fp_read_data->fp_comm, &(fp_read_data->fp_comm_rank));
fp_read_data->fp_cm = CManager_create();
if(transport == NULL){
if(CMlisten(fp_read_data->fp_cm) == 0) {
fprintf(stderr, "Flexpath ERROR: reader %d unable to initialize connection manager.\n",
fp_read_data->fp_comm_rank);
}
}else{
listen_list = create_attr_list();
add_attr(listen_list, fp_read_data->CM_TRANSPORT, Attr_String,
(attr_value)strdup(transport));
CMlisten_specific(fp_read_data->fp_cm, listen_list);
}
int forked = CMfork_comm_thread(fp_read_data->fp_cm);
if(!forked) {
fprintf(stderr, "reader %d failed to fork comm_thread.\n", fp_read_data->fp_comm_rank);
/*log_debug( "forked\n");*/
}
return 0;
}
int
main(int argc, char **argv)
{
char *test_only = NULL;
int i = 1;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-v") == 0) {
verbose++;
} else if (strcmp(argv[i], "-test_only") == 0){
test_only = argv[++i];
} else {
printf("Unknown argument %s\n", argv[i]);
}
}
if (!test_only || (strcmp(test_only, "paramattr") == 0)) {
static char extern_string[] = "int printf(string format, ...);";
#ifndef PRINTF_DEFINED
extern int printf();
#endif
static cod_extern_entry externs[] =
{
{"printf", (void*)(long)printf},
{(void*)0, (void*)0}
};
/* test external call */
static char code[] = "{\
if (attr_set(l, \"test_value\")) {\n\
return attr_ivalue(l, \"test_value\");\n\
}\n\
return 0;\n\
}";
cod_parse_context context = new_cod_parse_context();
cod_parse_context context2;
cod_code gen_code;
int (*func)(attr_list l);
attr_list l;
cod_assoc_externs(context, externs);
cod_parse_for_context(extern_string, context);
context2 = cod_copy_context(context);
l = create_attr_list();
set_attr(l, attr_atom_from_string("test_value"), Attr_Int4, (attr_value)15);
cod_subroutine_declaration("int proc(attr_list l)", context);
gen_code = cod_code_gen(code, context);
func = (int (*)(attr_list))(long)gen_code->func;
if ((func)(l) != 15) {
printf("Function didn't return 15\n");
}
cod_code_free(gen_code);
cod_free_parse_context(context);
cod_subroutine_declaration("int proc(attr_list l)", context2);
gen_code = cod_code_gen(code, context2);
func = (int (*)(attr_list))(long)gen_code->func;
if ((func)(l) != 15) {
printf("Function didn't return 15\n");
}
free_attr_list(l);
cod_code_free(gen_code);
cod_free_parse_context(context2);
}
static int
raw_handler(CManager cm, void *vevent, int len, void *client_data, attr_list attrs)
{
ADIOS_FILE *adiosfile = client_data;
flexpath_reader_file *fp = (flexpath_reader_file*)adiosfile->fh;
double data_end = dgettimeofday();
if(fp->time_in == 0.00)
fp->time_in = data_end; // used for perf measurements only
int condition;
int writer_rank;
int flush_id;
double data_start;
get_double_attr(attrs, attr_atom_from_string("fp_starttime"), &data_start);
get_int_attr(attrs, attr_atom_from_string("fp_dst_condition"), &condition);
get_int_attr(attrs, attr_atom_from_string(FP_RANK_ATTR_NAME), &writer_rank);
get_int_attr(attrs, attr_atom_from_string("fp_flush_id"), &flush_id);
double format_start = dgettimeofday();
FMContext context = CMget_FMcontext(cm);
void *base_data = FMheader_skip(context, vevent);
FMFormat format = FMformat_from_ID(context, vevent);
// copy //FMfree_struct_desc_list call
FMStructDescList struct_list =
FMcopy_struct_list(format_list_of_FMFormat(format));
FMField *f = struct_list[0].field_list;
#if 0
uint64_t packet_size = calc_ffspacket_size(f, attrs, base_data);
fp->data_read += packet_size;
#endif
/* setting up initial vars from the format list that comes along with the
message. Message contains both an FFS description and the data. */
if(fp->num_vars == 0){
int var_count = 0;
fp->var_list = setup_flexpath_vars(f, &var_count);
adiosfile->var_namelist = malloc(var_count * sizeof(char *));
int i = 0;
while(f->field_name != NULL) {
adiosfile->var_namelist[i++] = strdup(f->field_name);
f++;
}
adiosfile->nvars = var_count;
fp->num_vars = var_count;
}
f = struct_list[0].field_list;
char *curr_offset = NULL;
while(f->field_name){
char atom_name[200] = "";
flexpath_var *var = find_fp_var(fp->var_list, f->field_name);
if(!var){
adios_error(err_file_open_error,
"file not opened correctly. var does not match format.\n");
return err_file_open_error;
}
int num_dims = get_ndims_attr(f->field_name, attrs);
var->num_dims = num_dims;
flexpath_var_chunk *curr_chunk = &var->chunks[0];
// has the var been scheduled?
if(var->sel){
if(var->sel->type == ADIOS_SELECTION_WRITEBLOCK){
if(num_dims == 0){ // writeblock selection for scalar
if(var->sel->u.block.index == writer_rank){
void *tmp_data = get_FMfieldAddr_by_name(f, f->field_name, base_data);
memcpy(var->chunks[0].user_buf, tmp_data, f->field_size);
}
}
else { // writeblock selection for arrays
/* if(var->num_dims == 0){ */
/* var->global_dims = malloc(sizeof(uint64_t)*num_dims); */
/* } */
if(var->sel->u.block.index == writer_rank){
var->array_size = var->type_size;
int i;
for(i=0; i<num_dims; i++){
char *dim;
atom_name[0] ='\0';
strcat(atom_name, FP_DIM_ATTR_NAME);
strcat(atom_name, "_");
strcat(atom_name, f->field_name);
strcat(atom_name, "_");
char dim_num[10] = "";
sprintf(dim_num, "%d", i+1);
strcat(atom_name, dim_num);
get_string_attr(attrs, attr_atom_from_string(atom_name), &dim);
FMField *temp_field = find_field_by_name(dim, f);
if(!temp_field){
adios_error(err_corrupted_variable,
"Could not find fieldname: %s\n",
dim);
}
else{
int *temp_data = get_FMfieldAddr_by_name(temp_field,
temp_field->field_name,
base_data);
uint64_t dim = (uint64_t)(*temp_data);
var->array_size = var->array_size * dim;
}
}
void *arrays_data = get_FMPtrField_by_name(f, f->field_name, base_data, 1);
memcpy(var->chunks[0].user_buf, arrays_data, var->array_size);
}
}
}
else if(var->sel->type == ADIOS_SELECTION_BOUNDINGBOX){
if(num_dims == 0){ // scalars; throw error
adios_error(err_offset_required,
"Only scalars can be scheduled with write_block selection.\n");
}
else{ // arrays
int i;
global_var *gv = find_gbl_var(fp->gp->vars,
var->varname,
fp->gp->num_vars);
array_displacements * disp = find_displacement(var->displ,
writer_rank,
var->num_displ);
if(disp){ // does this writer hold a chunk we've asked for, for this var?
uint64_t *temp = gv->offsets[0].local_dimensions;
int offsets_per_rank = gv->offsets[0].offsets_per_rank;
uint64_t *writer_sizes = &temp[offsets_per_rank * writer_rank];
uint64_t *sel_start = disp->start;
uint64_t *sel_count = disp->count;
char *writer_array = (char*)get_FMPtrField_by_name(f,
f->field_name,
base_data, 1);
char *reader_array = (char*)var->chunks[0].user_buf;
uint64_t reader_start_pos = disp->pos;
var->start_position += copyarray(writer_sizes,
sel_start,
sel_count,
disp->ndims,
f->field_size,
0,
writer_array,
reader_array+reader_start_pos);
}
}
}
}
else { //var has not been scheduled;
if(num_dims == 0){ // only worry about scalars
flexpath_var_chunk *chunk = &var->chunks[0];
if(!chunk->has_data){
void *tmp_data = get_FMfieldAddr_by_name(f, f->field_name, base_data);
chunk->data = malloc(f->field_size);
memcpy(chunk->data, tmp_data, f->field_size);
chunk->has_data = 1;
}
}
}
f++;
}
if(condition == -1){
fp->completed_requests++;
if(fp->completed_requests == fp->pending_requests){
pthread_mutex_lock(&fp->data_mutex);
pthread_cond_signal(&fp->data_condition);
pthread_mutex_unlock(&fp->data_mutex);
}
}
else{
CMCondition_signal(fp_read_data->fp_cm, condition);
}
free_fmstructdesclist(struct_list);
return 0;
}
int main (int argc, char *argv[])
{
char log_name[100];
char * cod_func = "int i;\n\
float total = 0;\n\
for(i = 0; i < the_size; ++i)\n\
{\n\
float * temp_float_ptr;\n\
entity_float_data_change_event * old_event;\n\
old_event = EVdata_entity_float_data_change_event(i);\n\
temp_float_ptr = &(old_event->float_data.data[0]);\n\
total = total + (*temp_float_ptr);\n\
}\n\
float average;\n\
average = total / the_size;\n\
printf(\"The value of average is: \\%f\\n\", average);\n\
entity_float_data_change_event new_event;\n\
entity_float_data_change_event * old_event = EVdata_entity_float_data_change_event(0);\n\
new_event.float_data.data_size = 1;\n\
new_event.float_data.data[0] = average;\n\
for(i = 0; i < 32; ++i)\n\
{\n\
new_event.entity_id.id[i] = old_event->entity_id.id[i];\n\
}\n\
EVsubmit(0, new_event);\n\0";
if (argc != 3)
{
fprintf(stderr, "Usage: client_modify pos_unique_number [123], where unique_number is a positive or zero unique number for the group\n"
"And the second number is a identifier for which group the fprintf is submitting too...\n");
exit(1);
}
proc_id = atoi(argv[1]);
group_id = atoi(argv[2]);
if (group_id != 1 && group_id != 2 && group_id != 3)
{
fprintf(stderr, "Error: the group id should be one, two or three. It is: %d\n", group_id);
exit(1);
}
strcpy(send_group, "/experimental/pool");
strcat(send_group, argv[2]);
strcpy(log_name, "modify_");
strcat(log_name, argv[1]);
strcat(log_name, argv[2]);
if(!initialize_log(log_name))
{
fprintf(stderr, "Error: log not initialized, quitting!\n");
exit(1);
}
printf("Program starting\n");
srand(time(NULL));
/* Set up sigaction for handler call */
struct sigaction sa;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
sa.sa_handler = alarm_handler;
if(sigaction(SIGALRM, &sa, NULL) == -1)
{
fprintf(stderr, "SIGALRM sigaction failed!\n");
exit(1);
}
float temp_float = get_rand_float();
char **bindings;
int i2;
atom_t VAL1_ATOM, VAL2_ATOM;
ft.data = &temp_float;
ft.data_size = 1;
pds_host = getenv ("PDS_SERVER_HOST");
if (!pds_host && !access(PDS_CONNECT_FILE, F_OK))
{
char hostname[128];
FILE * temp_ptr = fopen(PDS_CONNECT_FILE, "r");
fscanf(temp_ptr, "%s", hostname);
printf("Hostname is: %s\n", hostname);
fclose(temp_ptr);
pds_host = strdup(hostname);
}
if (pds_host == NULL)
pds_host = getenv ("HOSTNAME");
if (pds_host == NULL) {
char hostname[128];
if (gethostname(&hostname[0], sizeof(hostname)) == 0) {
pds_host = strdup(hostname);
}
}
contact_attrs = create_attr_list();
set_attr (contact_attrs,
attr_atom_from_string("IP_HOST"),
Attr_String,
strdup (pds_host));
set_attr (contact_attrs,
attr_atom_from_string("IP_PORT"),
Attr_Int4,
(attr_value*)8848);
/* Get the CM from the client_manager
cm = CManager_create();
CMlisten(cm);*/
if ((wps = pds_service_open (contact_attrs)) == NULL)
{
fprintf (stderr, "Couldn't init PDS client-side (is pdsd running?)\n");
exit (1);
}
cm = pds_get_CManager();
new_domain_id = pds_open_domain (wps,
"newDomain",
"newDomaintype",
1,
"wp-register");
cid1 = pds_get_root_context (new_domain_id);
if((atoi(argv[1])) == 0)
{
eid1 = pds_create_entity_float (new_domain_id, send_group, null_pds_context_id, &ft, NULL);
if(!pds_aggregate_entity(new_domain_id, cod_func, eid1, ENTITY_DATA_CHANGE_FLOAT))
{
fprintf(stderr, "Error: pds_aggregate_entity failed\n");
return 1;
}
}
if((pds_set_entity_float_data (new_domain_id, send_group, cid1, &ft, 0)) > 0 )
printf("Successfully set the new float data, should see something in the other program.\n");
else
printf ("Failed to set the new float data\n");
fflush (0);
alarm(2);
CMrun_network(cm);
pds_service_close (wps);
return 0;
}
void
set_contact_list (attr_list contact_list,
const icee_transport_t icee_transport,
char *host, int port)
{
switch (icee_transport)
{
case ENET:
add_string_attr(contact_list,
attr_atom_from_string("CM_TRANSPORT"),
"enet");
add_string_attr(contact_list,
attr_atom_from_string("CM_ENET_HOST"),
host);
add_int_attr(contact_list,
attr_atom_from_string("CM_ENET_PORT"),
port);
break;
case NNTI:
add_string_attr(contact_list,
attr_atom_from_string("CM_TRANSPORT"),
"nnti");
add_string_attr(contact_list,
attr_atom_from_string("IP_HOST"),
host);
add_int_attr(contact_list,
attr_atom_from_string("NNTI_PORT"),
port);
add_string_attr(contact_list,
attr_atom_from_string("CM_NNTI_TRANSPORT"),
"ib");
break;
case IB:
add_string_attr(contact_list,
attr_atom_from_string("CM_TRANSPORT"),
"ib");
add_string_attr(contact_list,
attr_atom_from_string("IP_HOST"),
host);
add_int_attr(contact_list,
attr_atom_from_string("IP_PORT"),
port);
break;
default:
add_string_attr(contact_list,
attr_atom_from_string("IP_HOST"),
host);
add_int_attr(contact_list,
attr_atom_from_string("IP_PORT"),
port);
break;
}
}
