vector<float> GaussianKernel1D(float sigma) {
assert (sigma > 0);
int dim = (int) max(3.0f, 2 * GAUSSKERN * sigma + 1.0f);
// make dim odd
if (dim % 2 == 0)
dim++;
//printf("GaussianKernel1D(): Creating 1x%d vector for sigma=%.3f gaussian kernel\n", dim, sigma);
vector<float> kern(dim);
float s2 = sigma * sigma;
int c = dim / 2;
for (int i = 0; i < (dim + 1) / 2; i++) {
float v = 1 / (2 * PI * s2) * exp(-(i*i) / (2 * s2));
kern[c+i] = v;
kern[c-i] = v;
}
normalizeVec(kern);
//for (unsigned int i = 0; i < kern.size(); i++)
// printf("%f\n", kern[i]);
return kern;
}
double operator()(configuration const& c) const {
auto delta = (rhs - kern(c)) / error_bars;
int M = first_dim(delta);
double kappa = 0;
for(int i = 1; i < M; ++i) kappa += corr(delta(i), delta(i-1));
kappa /= M - 1;
return kappa;
}
void tune_impl(parameter_database& paras, std::string parent)
{
typedef typename VclBasicType::value_type::value_type SCALARTYPE;
// create dummy vectors; the kernels have to be created ..
VclBasicType dummy;
// extract the kernels for which parameters are present
std::string kernel_str = parent+"/kernels/kernel/name/text()";
pugi::xpath_node_set kernel_res = paras.doc.select_nodes(kernel_str.c_str());
typedef std::vector<std::string> kernels_type;
kernels_type kernels;
std::cout << "Retrieving kernels..." << std::endl;
for (pugi::xpath_node_set::const_iterator it = kernel_res.begin(); it != kernel_res.end(); ++it)
{
std::stringstream ss;
it->node().print(ss, " ");
std::string kern(ss.str());
kern.erase(std::remove(kern.begin(), kern.end(), '\n'), kern.end()); //trim trailing linebreak
kernels.push_back(kern);
}
// retrieve the actual parameters
std::cout << "Retrieving actual parameters..." << std::endl;
for(typename kernels_type::iterator iter = kernels.begin();
iter != kernels.end(); iter++)
{
// retrieving the work group ..
std::string wg_str = parent+"/kernels/kernel[name='"+*iter+"']/params/param[name='"+val::globsize+"']/value/text()";
pugi::xpath_node_set wg_res = paras.doc.select_nodes(wg_str.c_str());
unsigned int global_size(0);
std::stringstream ss;
ss << wg_res[0].node().value();
ss >> global_size;
// retrieving the local_workers ..
std::string lw_str = parent+"/kernels/kernel[name='"+*iter+"']/params/param[name='"+val::locsize+"']/value/text()";
pugi::xpath_node_set lw_res = paras.doc.select_nodes(lw_str.c_str());
unsigned int local_workers(0);
ss.clear();
ss << lw_res[0].node().value();
ss >> local_workers;
//std::cout << "kernel: " << *iter << " wg: " << work_group << " lw: " << local_workers << std::endl;
// set the parameters
set_kernel_params<SCALARTYPE,1> (program_for_vcltype<VclBasicType>::get(), *iter, global_size, local_workers);
//set_kernel_params<SCALARTYPE,4> (*iter, work_group * local_workers, local_workers);
//set_kernel_params<SCALARTYPE,16>(*iter, work_group * local_workers, local_workers);
}
}
void PartionedManualMPSimExecutor::simulate()
{
try {
PartionedMRTKernel kern("PartionedKern");
TextTrace ttrace("run_log.txt");
JSONTrace jtrace("run_trace.json");
createSimCPUScheduler();
createSimTaskCPU();
createSimVMCPU();
GUI_CONTEXT.addPeriodicTasks();
GUI_CONTEXT.addVMs();
addCPUs2Kernel(kern);
addVMs2Kernel(kern, jtrace, ttrace);
addTasks2Kernel(kern, jtrace, ttrace);
SIMUL.run(_simulTime + 1);
} catch (BaseExc &e) {
GUI_CONTEXT.showMessageBox(e.what());
GUI_CONTEXT.erasePeriodicTask();
GUI_CONTEXT.erasePeriodicServerVM();
cleanExecutionData();
return;
}
showResult();
GUI_CONTEXT.erasePeriodicTask();
GUI_CONTEXT.erasePeriodicServerVM();
cleanExecutionData();
}
void Points::Rotate(char axis, int point_count, std::string title)
{
int g=point_count;
std::vector<int> index(g*g);
std::vector<int> rindex(g*g);
std::vector<int> It(g);
std::vector<double> theta(g);
std::vector<double> phi(g);
std::vector<double> theta_rotated(g);
std::vector<double> phi_rotated(g);
std::vector<double> theta_index(g*g);
std::vector<double> phi_index(g*g);
Points::kernel_map.resize(g);
Points::weight_map.resize(g);
Points::fkernel_map.resize(g);
Points::theta_prime.resize(g*g);
Points:: phi_prime.resize(g*g);
std::vector<std::vector<double> > kern(g);
std::vector<std::vector<double> > fkern(g);
std::vector<std::vector<double> > weight(g);
std::vector<std::vector<double> > rkern(g);
std::vector<std::vector<double> > rkern2(g);
std::vector<std::vector<double> > rotated_kern(g);
std::vector<double> r_weight(g*g);
std::vector<std::vector<double> > rfkernel_value(g);
std::vector<Vex> Original(g);
std::vector<Vex> Rotated(g);
Points::TtoZ.resize(g);
theta=Points::Theta;
phi=Points::Phi;
if(axis=='X')
{
theta_rotated=Points::theta_rotatedX;
phi_rotated=Points::phi_rotatedX;
}
else if(axis=='Y')
{
theta_rotated=Points::theta_rotatedY;
phi_rotated=Points::phi_rotatedY;
}
else if(axis=='Z')
{
theta_rotated=Points::theta_rotatedZ;
phi_rotated=Points::phi_rotatedZ;
}
else
{
}
std::vector<int> i_it(g*g);
std::vector<int> j_it(g*g);
for(int i=0; i<g; i++)
{
Original[i].SphericaltoXYZ(theta[i],phi[i],1.0);
Rotated[i].SphericaltoXYZ(theta_rotated[i], phi_rotated[i], 1.0);
// std::cout <<"x, y, z =" << Original[i].GetX() << ", " << Original[i].GetY() << ", "<< Original[i].GetZ() << ", "<< std::endl;
}
for(int i=0; i<g; i++)
{
kern[i].resize(g);
fkern[i].resize(g);
weight[i].resize(g);
rkern[i].resize(g);
rkern2[i].resize(g);
//std::cout << "original xyz = (" << Original[i].GetX() << ", " << Original[i].GetY() << ", " << Original[i].GetZ() << ")" << std::endl;
}
//------------ load unroated kernel matrix from file ------------------//
std::cout <<axis+title << std::endl;
std::ifstream kernel_read(title);
kernel_read.precision(15);
kernel_read.clear(); // clear fail and eof bits
kernel_read.seekg(0, std::ios::beg); // back to the start!
int u=0;
for(int i=0; i<g; i++)
{
kernel_map[i].resize(g);
fkernel_map[i].resize(g);
weight_map[i].resize(g);
for(int j=0; j<g; j++)
{
//kernel_read >> theta_index[u] >> phi_index[u] >> kern[i][j] >> fkern[i][j] >> weight[i][j];
kernel_read >> kern[i][j] >> fkern[i][j] >> weight[i][j];
u++;
}
}
kernel_read.close();
//--------------find index that matches rotation -----------------------//
for(int i=0; i<g; i++)
{
for(int j=0; j<g; j++)
{
if(Original[i]==Rotated[j])
{
Points::TtoZ[i] = Rotated[j];
It[i]=j;
}
}
}
//-------------------use rotated index to map kernel ------------------------//
for(int i=0; i<g; i++)
{
Points::theta_prime[i]=theta[ It[i] ];
Points::phi_prime[i]=phi[ It[i] ];
for(int j=0; j<g; j++)
{
Points::kernel_map[i][j]=kern[ It[i] ][ It[j] ];
Points::fkernel_map[i][j]=fkern[ It[i] ][ It[j] ];
Points::weight_map[i][j]=weight[ It[i] ][ It[j] ];
}
}
std::cout << std::endl;
std::cout << "Rotation Passed! " << std::endl;
std::cout << std::endl;
}
int main(int argc, char *argv[])
{
Teuchos::oblackholestream blackhole;
Teuchos::GlobalMPISession mpiSession(&argc,&argv,&blackhole);
//
// Get the default communicator and node
//
auto &platform = Tpetra::DefaultPlatform::getDefaultPlatform();
auto comm = platform.getComm();
auto node = platform.getNode();
const int myImageID = comm->getRank();
const int numImages = comm->getSize();
const bool verbose = (myImageID==0);
//
// Say hello, print some communicator info
//
if (verbose) {
std::cout << "\n" << Tpetra::version() << std::endl;
std::cout << "Comm info: " << *comm;
std::cout << "Node type: " << Teuchos::typeName(*node) << std::endl;
std::cout << std::endl;
}
//
// Create a simple map for domain and range
//
Tpetra::global_size_t numGlobalRows = 1000*numImages;
auto map = Tpetra::createUniformContigMapWithNode<int,int>(numGlobalRows, comm, node);
auto x = Tpetra::createVector<double>(map),
y = Tpetra::createVector<double>(map);
// Create a simple diagonal operator using lambda function
auto fTwoOp = Tpetra::RTI::binaryOp<double>( [](double /*y*/, double x) { return 2.0 * x; } , map );
// y = 3*fTwoOp*x + 2*y = 3*2*1 + 2*1 = 8
x->putScalar(1.0);
y->putScalar(1.0);
fTwoOp->apply( *x, *y, Teuchos::NO_TRANS, 3.0, 2.0 );
// check that y == eights
double norm = y->norm1();
if (verbose) {
std::cout << "Tpetra::RTI::binaryOp" << std::endl
<< "norm(y) result == " << std::setprecision(2) << std::scientific << norm
<< ", expected value is " << numGlobalRows * 8.0 << std::endl;
}
//
// Create a finite-difference stencil using a Kokkos kernel and non-trivial maps
//
decltype(map) colmap;
if (numImages > 1) {
Teuchos::Array<int> colElements;
Teuchos::ArrayView<const int> rowElements = map->getNodeElementList();
// This isn't the most efficient Map/Import layout, but it makes for a very straight-forward kernel
if (myImageID != 0) colElements.push_back( map->getMinGlobalIndex() - 1 );
colElements.insert(colElements.end(), rowElements.begin(), rowElements.end());
if (myImageID != numImages-1) colElements.push_back( map->getMaxGlobalIndex() + 1 );
colmap = Tpetra::createNonContigMapWithNode<int,int>(colElements(), comm, node);
}
else {
colmap = map;
}
auto importer = createImport(map,colmap);
// Finite-difference kernel = tridiag(-1, 2, -1)
FDStencil<double> kern(myImageID, numImages, map->getNodeNumElements(), -1.0, 2.0, -1.0);
auto FDStencilOp = Tpetra::RTI::kernelOp<double>( kern, map, map, importer );
// x = ones(), FD(x) = [1 zeros() 1]
FDStencilOp->apply( *x, *y );
norm = y->norm1();
if (verbose) {
std::cout << std::endl
<< "TpetraExamples::FDStencil" << std::endl
<< "norm(y) result == " << std::setprecision(2) << std::scientific << norm
<< ", expected value is " << 2.0 << std::endl;
}
std::cout << "\nEnd Result: TEST PASSED" << std::endl;
return 0;
}
