//@HEADER

// ************************************************************************

//

// MiniFE: Simple Finite Element Assembly and Solve

// Copyright (2006-2013) Sandia Corporation

//

// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive

// license for use of this work by or on behalf of the U.S. Government.

//

// This library is free software; you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as

// published by the Free Software Foundation; either version 2.1 of the

// License, or (at your option) any later version.

//

// This library is distributed in the hope that it will be useful, but

// WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

// Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

// USA

//

// ************************************************************************

//@HEADER

#include <string>

#include <iostream>

#include <sstream>

#include <fstream>

#ifdef HAVE_MPI

#include <mpi.h>

#endif

#ifdef MINIFE_HAVE_TPI

#include <TPI.h>

#endif

#ifdef MINIFE_HAVE_TBB

#include <tbb/task_scheduler_init.h>

#endif

#include <param_utils.hpp>

#include <Parameters.hpp>

#include <utils.hpp>

namespace miniFE {

//-------------------------------------------------------------

void get_parameters(int argc, char** argv, Parameters& params)

{

std::string argstring;

Mantevo::read_args_into_string(argc, argv, argstring);

std::string garbage("garbage");

std::string filename =

Mantevo::parse_parameter<std::string>(argstring, "input_file", garbage);

if (filename != garbage) {

Mantevo::read_file_into_string(filename, argstring);

}

params.nx = Mantevo::parse_parameter<int>(argstring, "nx", 10);

params.ny = Mantevo::parse_parameter<int>(argstring, "ny", params.nx);

params.nz = Mantevo::parse_parameter<int>(argstring, "nz", params.ny);

params.load_imbalance =

Mantevo::parse_parameter<float>(argstring, "load_imbalance", 0);

params.numthreads = Mantevo::parse_parameter<int>(argstring, "numthreads", 1);

params.mv_overlap_comm_comp = Mantevo::parse_parameter<int>(argstring, "mv_overlap_comm_comp", 0);

params.use_locking = Mantevo::parse_parameter<int>(argstring, "use_locking", 0);

params.name = Mantevo::parse_parameter<std::string>(argstring, "name","");

params.elem_group_size = Mantevo::parse_parameter<int>(argstring, "elem_group_size", 1);

params.use_elem_mat_fields = Mantevo::parse_parameter<int>(argstring, "use_elem_mat_fields", 1);

params.verify_solution = Mantevo::parse_parameter<int>(argstring, "verify_solution", 0);

params.device = Mantevo::parse_parameter<int>(argstring, "device", 0);

params.num_devices = Mantevo::parse_parameter<int>(argstring, "num_devices", 2);

params.skip_device = Mantevo::parse_parameter<int>(argstring, "skip_device", 9999);

params.numa = Mantevo::parse_parameter<int>(argstring, "numa", 1);

}

//-------------------------------------------------------------

void broadcast_parameters(Parameters& params)

{

#ifdef HAVE_MPI

const int num_int_params = 13;

int iparams[num_int_params] = {params.nx, params.ny, params.nz, params.numthreads, params.mv_overlap_comm_comp, params.use_locking,

params.elem_group_size, params.use_elem_mat_fields, params.verify_solution,

params.device, params.num_devices,params.skip_device,params.numa};

MPI_Bcast(&iparams[0], num_int_params, MPI_INT, 0, MPI_COMM_WORLD);

params.nx = iparams[0];

params.ny = iparams[1];

params.nz = iparams[2];

params.numthreads = iparams[3];

params.mv_overlap_comm_comp = iparams[4];

params.use_locking = iparams[5];

params.elem_group_size = iparams[6];

params.use_elem_mat_fields = iparams[7];

params.verify_solution = iparams[8];

params.device = iparams[9];

params.num_devices = iparams[10];

params.skip_device = iparams[11];

params.numa = iparams[12];

float fparams[1] = {params.load_imbalance};

MPI_Bcast(&fparams[0], 1, MPI_FLOAT, 0, MPI_COMM_WORLD);

params.load_imbalance = fparams[0];

#endif

}

//-------------------------------------------------------------

void initialize_mpi(int argc, char** argv, int& numprocs, int& myproc)

{

#ifdef HAVE_MPI

MPI_Init(&argc, &argv);

MPI_Comm_size(MPI_COMM_WORLD, &numprocs);

MPI_Comm_rank(MPI_COMM_WORLD, &myproc);

#else

numprocs = 1;

myproc = 0;

#endif

}

//-------------------------------------------------------------

void finalize_mpi()

{

#ifdef HAVE_MPI

MPI_Finalize();

#endif

}

}//namespace miniFE