~ubuntu-branches/ubuntu/vivid/adios/vivid-proposed

 

static int adios_mpi_amr_initialized = 0;

 

#define FREE(v) \

  if (v)        \

  {             \

    int g_have_mdf;

    int g_merging_pgs;

    int g_num_ost;

    int g_threading;

    int g_color1;

    int g_color2;

    MPI_Offset * g_offsets;

        char uuid[40];

};

 

static void trim_spaces (char * str)

{

    char * t = str, * p = NULL;

    return ost_list;

}

 

static void

//adios_mpi_amr_set_striping_unit(MPI_File fh, char *filename, char *parameters)

adios_mpi_amr_set_striping_unit(struct adios_MPI_data_struct * md, char *parameters)

{

    char * filename = md->subfile_name;

    uint64_t striping_unit = 0;

    uint16_t striping_count = 0;

 

    temp_string = (char *) malloc (strlen (parameters) + 1);

    strcpy (temp_string, parameters);

    trim_spaces (temp_string);

 

    {

        char * p = strchr (p_count, '=');

        char * q = strtok (p, ";");

    strcpy (temp_string, parameters);

    trim_spaces (temp_string);

 

    {

        char * p = strchr (p_size, '=');

        char * q = strtok (p, ";");

            i++;

        }

 

        ioctl (fd, LL_IOC_LOV_SETSTRIPE

              ,(void *) &lum

              );

static void

adios_mpi_amr_set_have_mdf (char * parameters, struct adios_MPI_data_struct * md)

{

 

    temp_string = (char *) malloc (strlen (parameters) + 1);

    strcpy (temp_string, parameters);

    trim_spaces (temp_string);

 

    {

        char * p = strchr (p_size, '=');

        char * q = strtok (p, ";");

static void

adios_mpi_amr_set_aggregation_parameters(char * parameters, struct adios_MPI_data_struct * md)

{

    int nproc = md->size, rank = md->rank;

 

    temp_string = (char *) malloc (strlen (parameters) + 1);

 

    strcpy (temp_string, parameters);

    trim_spaces (temp_string);

 

    {

        char * p = strchr (p_size, '=');

        char * q = strtok (p, ";");

    strcpy (temp_string, parameters);

    trim_spaces (temp_string);

 

    // set up # of aggregators

    {

        char * p = strchr (p_size, '=');

        char * q = strtok (p, ";");

        }

    }

 

    {

        char * p = strchr (p_size, '=');

        char * q = strtok (p, ";");

    strcpy (temp_string, parameters);

    trim_spaces (temp_string);

 

    {

        char * p = strchr (p_size, '=');

        char * q = strtok (p, ";");

 

    md->g_ost_skipping_list = allocOSTList (md->g_num_ost);

 

    {

        char * p = strchr (p_size, '=');

        char * q = strtok (p, ";");

    strcpy (temp_string, parameters);

    trim_spaces (temp_string);

 

    {

        char * p = strchr (p_size, '=');

        char * q = strtok (p, ";");

    }

    memset (md->g_is_aggregator, 0, nproc * sizeof(int));

 

    }

}

 

 

    while (total_written < len)

    {

        MPI_File_write (fh, buf_ptr, write_len, MPI_BYTE, &status);

        MPI_Get_count(&status, MPI_BYTE, &count);

        if (count != write_len)

                                         ,struct adios_index_struct_v1 * index

                                          )

{

    struct adios_index_var_struct_v1 * vars_root = index->vars_root;

    struct adios_index_attribute_struct_v1 * attrs_root = index->attrs_root;

    int len;

}

 

 

{

    // 4 bytes for ".dir" 

    

    mkdir (dir_name, S_IRWXU | S_IRWXG);

  

void * adios_mpi_amr_do_open_thread (void * param)

{

    struct adios_MPI_thread_data_open * td = (struct adios_MPI_thread_data_open *) param;

 

    unlink (td->md->subfile_name);

    if (td->parameters)

 

    }

 

 

    return NULL;

}

    md->g_have_mdf = 1;

    md->g_merging_pgs = 0;

    md->g_num_ost = 0;

    md->g_threading = 0;

    md->g_color1 = 0;

    md->g_color2 = 0;

    md->g_offsets = 0;

    md->g_io_type = ADIOS_MPI_AMR_IO_BG;

 

    adios_buffer_struct_init (&md->b);

}

 

 

    return 1;

}

 

static

void build_offsets (struct adios_bp_buffer_struct_v1 * b

                   ,MPI_Offset * offsets, uint64_t size, char * group_name

        pg_root = pg_root->next;

    }

}

 

enum ADIOS_FLAG adios_mpi_amr_should_buffer (struct adios_file_struct * fd

                                            ,struct adios_method_struct * method

                                            )

{

    struct adios_MPI_data_struct * md = (struct adios_MPI_data_struct *)

                                                      method->method_data;

    char * name, * name_no_path, * ch;

    int err;

 

    START_TIMER (ADIOS_TIMER_MPI_AMR_AD_SHOULD_BUFFER);

 

    name = malloc (strlen (method->base_path) + strlen (fd->name) + 1);

    sprintf (name, "%s%s", method->base_path, fd->name);

 

    fd->base_offset = 0;

 

    switch (fd->mode)

            if (md->rank == 0)

            {

                struct lov_user_md lum;

 

                // open metadata file

 

                adios_mpi_amr_set_have_mdf (method->parameters, md);

                if (md->g_have_mdf)

                {

                    if (f == -1)

                    {

                        return -1;

                    }

 

 

                    ioctl (f, LL_IOC_LOV_SETSTRIPE ,(void *) &lum);

#ifdef HAVE_LUSTRE

                    md->g_num_ost = 1024;

                    rc = llapi_lov_get_uuids(f, uuids, &md->g_num_ost);

                    if (rc != 0)

#endif 

                    close (f);

 

                                  ,MPI_MODE_WRONLY | MPI_MODE_CREATE

                                  ,MPI_INFO_NULL

                                  ,&md->mfh

                                  );

                }

 

            }

 

            MPI_Bcast (&md->g_num_ost, 1, MPI_INT, 0, md->group_comm);

            fd->pg_start_in_file = 0;

            adios_mpi_amr_set_aggregation_parameters (method->parameters, md);

 

            // Check if fd->name contains path

            {

                name_no_path = malloc (strlen (ch + 1) + 1); 

                strcpy (name_no_path, ch + 1); 

                strcpy (name_no_path, fd->name);

            }

 

            // create the subfile name, e.g. restart.bp.1

            // 1 for '.' + 10 for subfile index + 1 for '\0'

            md->subfile_name = strdup (name);

            fd->subfile_index = (uint32_t)md->g_color1;

 

            adios_error (err_invalid_file_mode, "MPI_AGGREGATE method: Append mode is not supported.\n");

            break;

#if 0

            int old_file = 1;

            adios_buffer_struct_clear (&md->b);

 

    v->data_size = buffer_size;

}

 

static void adios_mpi_amr_do_read (struct adios_file_struct * fd

                              ,struct adios_method_struct * method

                              )

    data.buffer = 0;

    data.buffer_len = 0;

 

    {

        case 1:

        {

            // the three section headers

            struct adios_process_group_header_struct_v1 pg_header;

        default:

            adios_error (err_invalid_file_version, 

                    "MPI_AMR method read: file version unknown: %u\n",

            return;

    }

 

    adios_buffer_struct_clear (&md->b);

}

 

static

uint32_t adios_mpi_amr_calculate_attributes_size (struct adios_file_struct * fd)

            uint64_t buffer_size = 0;

            uint64_t buffer_offset = 0;

            uint64_t index_start = md->b.pg_index_offset, index_start1;

            void * aggr_buff = 0, * recv_buff = 0;

            struct adios_MPI_thread_data_write write_thread_data;

            int i, new_rank, new_group_size, new_rank2, new_group_size2, max_data_size = 0, total_data_size = 0, total_data_size1 = 0;

            if (fd->shared_buffer == adios_flag_yes && !md->g_merging_pgs)

            {

                //printf ("do not merge pg\n");

                MPI_Request request;

                MPI_Status status;

 

                    if (2 * max_data_size > MAX_AGG_BUF)

                    {

                        log_warn ("MPI_AMR method (BG): The max allowed aggregation "

                                MAX_AGG_BUF, 2 * max_data_size);

                    }

 

                    if (aggr_buff == 0 || recv_buff == 0)

                    {

                        adios_error (err_no_memory, "MPI_AMR method (BG): Cannot allocate "

                                    max_data_size);

                        return;

                    }

                    if (max_data_size > MAX_AGG_BUF)

                    {

                        log_warn ("MPI_AMR method (BG): The max allowed aggregation "

                                  MAX_AGG_BUF);

                    }

 

                    if (recv_buff == 0)

                    {

                        adios_error (err_no_memory, "MPI_AMR method (BG): Cannot allocate "

                                    max_data_size);

                        return;

                    }

                if (!is_aggregator(md->rank))

                {

                    uint64_t var_offset_to_add = 0, attr_offset_to_add = 0;

 

                    for (i = 0; i < new_rank; i++)

                    {

                // write out the metadata file from rank 0

                if (md->rank == 0)

                {

                    char * global_index_buffer = 0;

                    uint64_t global_index_buffer_size = 0;

                    uint64_t global_index_buffer_offset = 0;

 

            md->g_num_aggregators = 0;

            md->g_have_mdf = 1;

            md->g_color1 = 0;

            md->g_color2 = 0;

 

    md->mfh = 0;

    md->req = 0;

    memset (&md->status, 0, sizeof (MPI_Status));

 

    adios_clear_index_v1 (md->index);

    return;

 

                    if (count != md->vars_header_size)

                    {

                                md->vars_header_size, count);

                    }

                }

            if (fd->shared_buffer == adios_flag_yes && !md->g_merging_pgs)

            {

                //printf ("do not merge pg\n");

 

                pg_size = fd->bytes_written;

                pg_sizes = (int *) malloc (new_group_size * 4);

                {

                    if (total_data_size > MAX_AGG_BUF)

                    {

                                "Need to increase the number of aggregators.\n",

                                MAX_AGG_BUF, total_data_size);

                    }

                    if (aggr_buff == 0)

                    {

                        adios_error (err_no_memory, 

                                "for aggregation buffer.\n"

                                "Need to increase the number of aggregators.\n",

                                total_data_size);

                    STOP_TIMER (ADIOS_TIMER_MPI_AMR_COMM);

                }

 

                if (is_aggregator(md->rank))

                {

#if 0

                    pthread_join (t, NULL);

          

                    write_thread_data.fh = &md->fh;

                if (!is_aggregator(md->rank))

                {

                    uint64_t var_offset_to_add = 0, attr_offset_to_add = 0;

 

                    for (i = 0; i < new_rank; i++)

                    {

            // write out the metadata file from rank 0

            if (md->rank == 0)

            {

                char * global_index_buffer = 0;

                uint64_t global_index_buffer_size = 0;

                uint64_t global_index_buffer_offset = 0;

 

            md->g_num_aggregators = 0;

            md->g_have_mdf = 1;

            md->g_color1 = 0;

            md->g_color2 = 0;

 

    md->mfh = 0;

    md->req = 0;

    memset (&md->status, 0, sizeof (MPI_Status));

 

    adios_clear_index_v1 (md->index);

}

                                                 method->method_data;

    adios_free_index_v1 (md->index);

 

    if (adios_mpi_amr_initialized)

        adios_mpi_amr_initialized = 0;

}