uint64_t
copyarray(
uint64_t *sizes,
uint64_t *sel_start,
uint64_t *sel_count,
int ndim,
int elem_size,
int writer_pos,
char *writer_array,
char *reader_array)
{
if(ndim == 1){
int start = elem_size * (writer_pos + sel_start[ndim-1]);
int end = (start + (elem_size)*(sel_count[ndim-1]));
memcpy(reader_array, writer_array + start, end-start);
return end-start;
}
else{
int end = sel_start[ndim-1] + sel_count[ndim-1];
int i;
int amt_copied = 0;
for(i = sel_start[ndim-1]; i<end; i++){
int pos = linearize(sizes, ndim);
pos *=i;
amt_copied += copyarray(sizes, sel_start, sel_count, ndim-1,
elem_size, writer_pos+pos, writer_array,
reader_array+amt_copied);
}
return amt_copied;
}
}
int main(int argc, char **argv) {
int numbers[5] = {1, 3, 4, 7, 4};
int numcopy[5] = copyarray(numbers, 5); // no -- buggy
int i;
for (i = 0; i < 5; i++) {
printf("numbers [%d]: %d; numcopy[%d]: %d\n",
i, numbers[i], i, numcopy[i]);
}
return 0;
}
int
main (int argc,
char *argv[])
{
int arr1[5] = {1, 2, 3, 4, 5};
int arr2[5];
copyarray (arr1, arr2, 5);
showarrelem (arr2, 5);
return 0;
}
int
main (int argc,
char *argv[])
{
int max_row;
int max_col;
int i, j;
int src[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
int dst[3][4];
max_row = sizeof (src) / sizeof (src[0]);
max_col = sizeof (src[0]) / sizeof (int);
printf ("원본 데이터 출력\n");
for (i = 0; i < max_row; ++i)
{
for (j = 0; j < max_col; ++j)
{
printf ("%4d ", src[i][j]);
}
printf ("\n");
}
for (i = 0; i < max_row; ++i)
{
copyarray (src[i], dst[i], max_col);
}
max_row = sizeof (dst) / sizeof (dst[0]);
max_col = sizeof (dst[0]) / sizeof (int);
printf ("\n");
printf ("복사본 데이터 출력\n");
for (i = 0; i < max_row; ++i)
{
for (j = 0; j < max_col; ++j)
{
printf ("%4d ", dst[i][j]);
}
printf ("\n");
}
return 0;
}
int
main (int argc,
char *argv[])
{
int len;
int src[SRC_MAX] = { 2, 65, 45, 75, 33, 65, 667, 334, 234, 4 };
int dst[SRC_MAX];
len = sizeof (src) / sizeof (int);
print_array (src, len);
copyarray (src, dst, len);
len = sizeof (dst) / sizeof (int);
print_array (dst, len);
return 0;
}
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;
}
void spantree(board *init)
{
int i,j,mi,ni=-1;
for(j=0;j<valor;j++)
{
if(init->s[j]==0)
{
mi=j;
break;
}
}
level++;
if(level==5)
{
level--;
return;
}
else
init->children=moves[mi][4];
for(i=0;i<init->children;i++)
{
board *temp=getboard();
for(j=0;j<valor;j++)
{
if(init->s[j]==0)
{
mi=j;
break;
}
}
for(j=0;j<4;j++)
{
if(moves[mi][j]!=-1 && j>ni)
{
ni=j;
break;
}
}
switch((i+1))
{
case 1:
init->c1=temp;
copyarray(init->path,temp->path,init->pi);
temp->pi=init->pi;
temp->path[(temp->pi)++]=1;
makemove(init,init->c1,mi,ni);
spantree(init->c1);
break;
case 2:
init->c2=temp;
copyarray(init->path,temp->path,init->pi);
temp->pi=init->pi;
temp->path[(temp->pi)++]=2;
makemove(init,init->c2,mi,ni);
spantree(init->c2);
break;
case 3:
init->c3=temp;
copyarray(init->path,temp->path,init->pi);
temp->pi=init->pi;
temp->path[(temp->pi)++]=3;
makemove(init,init->c3,mi,ni);
spantree(init->c3);
break;
case 4:
init->c4=temp;
copyarray(init->path,temp->path,init->pi);
temp->pi=init->pi;
temp->path[(temp->pi)++]=4;
makemove(init,init->c4,mi,ni);
spantree(init->c4);
break;
default:
printf("\nNO TIENE HIJOS");
}
}
level--;
return;
}
