int main(int argc, char **argv)
{
OptionParser op;
op.addOption("verbose", OPT_BOOL, "", "enable verbose output", 'v');
op.addOption("passes", OPT_INT, "10", "specify number of passes", 'n');
op.addOption("size", OPT_INT, "1", "specify problem size", 's');
op.addOption("target", OPT_INT, "0", "specify MIC target device number", 't');
// If benchmark has any specific options, add those
addBenchmarkSpecOptions(op);
if (!op.parse(argc, argv))
{
op.usage();
return -1;
}
ResultDatabase resultDB;
// Run the test
RunBenchmark(op, resultDB);
// Print out results to stdout
resultDB.DumpDetailed(cout);
return 0;
}
int t1only_main(int argc, char *argv[], int nb_pars, OptionParser & options){
if (argc - nb_pars < 4)
{
cerr<<"too few arguments"<<endl;
options.usage(); return -1;
}
int count_arg = nb_pars;
const string inputt1(argv[count_arg]);
count_arg++;
const string mesh(argv[count_arg]);
count_arg++;
const string matrix(argv[count_arg]);
count_arg++;
const string outputstr(argv[count_arg]);
//load the mesh
Mesh m;
m.load(mesh);
//load the matrix
trMatrix M;
ifstream f(matrix.c_str());
if (f.is_open())
{
f>>M.m11>>M.m12>>M.m13>>M.m14>>M.m21>>M.m22>>M.m23>>M.m24>>M.m31>>M.m32>>M.m33>>M.m34>>M.m41>>M.m42>>M.m43>>M.m44;
f.close();
}
void operator() (const Option& option, const string& opt, const string& val, const OptionParser& parser) {
counter++;
cout << "--- MyCallback --- " << counter << ". time called" << endl;
cout << "--- MyCallback --- option.action(): " << option.action() << endl;
cout << "--- MyCallback --- opt: " << opt << endl;
cout << "--- MyCallback --- val: " << val << endl;
cout << "--- MyCallback --- parser.usage(): " << parser.usage() << endl;
cout << endl;
}
int
main(int argc, char** argv)
{
OptionParser options;
options.executable("lucb")
.program(DUNE_SHORT_NAME)
.copyright(DUNE_COPYRIGHT)
.email(DUNE_CONTACT)
.version(getFullVersion())
.date(getCompileDate())
.arch(DUNE_SYSTEM_NAME)
.description("Utility to update firmware of LUCL based devices.")
.add("-d", "--sys-device",
"System device", "DEVICE")
.add("-b", "--baud-rate",
"Baud rate", "BAUD")
.add("-i", "--i2c-address",
"I2C slave address", "I2C_ADDR")
.add("-f", "--file",
"iHEX file", "IHEX_FILE");
// Parse command line arguments.
if (!options.parse(argc, argv))
{
if (options.bad())
std::cerr << "ERROR: " << options.error() << std::endl;
options.usage();
return 1;
}
// Get iHEX file.
std::string ihex = options.value("--file");
if (ihex.empty())
{
std::cerr << "ERROR: you must specify one iHEX file." << std::endl;
return 1;
}
// Get system device.
std::string sys_dev = options.value("--sys-device");
if (sys_dev.empty())
{
std::cerr << "ERROR: you must specify one system device." << std::endl;
return 1;
}
// Get specified baud rate.
int baud = 0;
castLexical(options.value("--baud-rate"), baud);
// Get I2C address (if any).
bool is_i2c = false;
uint8_t i2c_addr = 0;
if (castLexical(options.value("--i2c-address"), i2c_addr))
{
if ((i2c_addr < 0x03) || (i2c_addr > 0x77))
{
std::cerr << "ERROR: I2C device address is out of range (0x03 - 0x77)" << std::endl;
return 1;
}
is_i2c = true;
}
LUCL::Protocol proto;
if (is_i2c)
proto.setI2C(sys_dev, i2c_addr);
else
proto.setUART(sys_dev);
try
{
LUCL::BootLoader boot(proto, true, baud);
boot.flash(ihex);
}
catch (std::exception& e)
{
std::cerr << "ERROR: " << e.what() << std::endl;
}
return 0;
}
int
main(int argc, char** argv)
{
OptionParser options;
options.executable(argv[0])
.program(DUNE_SHORT_NAME)
.copyright(DUNE_COPYRIGHT)
.email("Renato Caldas <*****@*****.**>")
.version(getFullVersion())
.date(getCompileDate())
.arch(DUNE_SYSTEM_NAME)
.description("Utility to update firmware of LUCL based devices.")
.add("-d", "--sys-device",
"System device", "DEVICE")
.add("-i", "--i2c-address",
"I2C slave address", "I2C_ADDR")
.add("-c", "--command",
"LUCL command", "CMD")
.add("-p", "--data-payload",
"LUCL data", "DATA0[,DATA1 ...]");
// Parse command line arguments.
if (!options.parse(argc, argv))
{
if (options.bad())
std::cerr << "ERROR: " << options.error() << std::endl;
options.usage();
return 1;
}
// Get system device.
std::string sys_dev = options.value("--sys-device");
if (sys_dev.empty())
{
std::cerr << "ERROR: you must specify one system device." << std::endl;
return 1;
}
// Get I2C address (if any).
bool is_i2c = false;
uint8_t i2c_addr = 0;
if (castLexical(options.value("--i2c-address"), i2c_addr))
{
if ((i2c_addr < 0x03) || (i2c_addr > 0x77))
{
std::cerr << "ERROR: I2C device address is out of range (0x03 - 0x77)" << std::endl;
return 1;
}
is_i2c = true;
}
// Open the device
LUCL::Protocol proto;
if (is_i2c)
proto.setI2C(sys_dev, i2c_addr);
else
proto.setUART(sys_dev);
try
{
proto.open();
}
catch (std::exception& e)
{
std::cerr << "ERROR: " << e.what() << std::endl;
return 1;
}
// Check for the command token
std::string command = options.value("--command");
if (command.empty())
{
std::cerr << "ERROR: reading from stdio not supported yet." << std::endl;
return 1;
}
// Get the data payload
std::string data_str = options.value("--data-payload");
std::vector<uint8_t> data_lst;
if (!castLexical(data_str, data_lst))
{
std::cerr << "ERROR: failed to parse the data payload argument." << std::endl;
return 1;
}
// Build and send the packet
if (command.compare("Info") == 0)
{
std::cerr << "Requesting device information" << std::endl;
try
{
proto.requestVersion();
}
catch (std::exception& e)
{
std::cerr << "ERROR: " << e.what() << std::endl;
return 1;
}
}
else if (command.compare("Reset") == 0)
{
std::cerr << "Requesting reset" << std::endl;
try
{
proto.requestReset();
}
catch (std::exception& e)
{
std::cerr << "ERROR: " << e.what() << std::endl;
return 1;
}
}
else
{
// Command string not recognized, attempt to interpret it as an integer
int cmd;
if (!castLexical(command, cmd))
{
std::cerr << "ERROR: bad command \"" << command << "\"" << std::endl;
return 1;
}
// Print the command and the data in a parseable format
std::cout << "Sending packet CMD " << cmd << " DATA";
for (unsigned i = 0; i < data_lst.size(); i++)
{
std::cout << " 0x" << std::hex << (int)data_lst[i];
}
std::cout << std::endl;
try
{
proto.sendCommand(cmd, (uint8_t*)(&data_lst[0]), (int)data_lst.size());
}
catch (std::exception& e)
{
std::cerr << "ERROR: " << e.what() << std::endl;
return 1;
}
}
// Handle the results
handleReply(proto);
return 0;
}
// ****************************************************************************
// Method: main()
//
// Purpose:
// serial and parallel main for OpenCL level0 benchmarks
//
// Arguments:
// argc, argv
//
// Programmer: SHOC Team
// Creation: The Epoch
//
// Modifications:
// Jeremy Meredith, Tue Jan 12 15:09:33 EST 2010
// Changed the way device selection works. It now defaults to the device
// index corresponding to the process's rank within a node if no devices
// are specified on the command command line, and otherwise, round-robins
// the list of devices among the tasks.
//
// Gabriel Marin, Tue Jun 01 15:38 EST 2010
// Check that we have valid (not NULL) context and queue objects before
// running the benchmarks. Errors inside CreateContextFromSingleDevice or
// CreateCommandQueueForContextAndDevice were not propagated out to the main
// program.
//
// Jeremy Meredith, Wed Nov 10 14:20:47 EST 2010
// Split timing reports into detailed and summary. For serial code, we
// report all trial values, and for parallel, skip the per-process vals.
// Also detect and print outliers from parallel runs.
//
// ****************************************************************************
int main(int argc, char *argv[])
{
int ret = 0;
try
{
#ifdef PARALLEL
int rank, size;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
cout << "MPI Task "<< rank << "/" << size - 1 << " starting....\n";
#endif
OptionParser op;
//Add shared options to the parser
op.addOption("platform", OPT_INT, "0", "specify OpenCL platform to use",
'p');
op.addOption("device", OPT_VECINT, "", "specify device(s) to run on", 'd');
op.addOption("passes", OPT_INT, "10", "specify number of passes", 'n');
op.addOption("size", OPT_VECINT, "1", "specify problem size", 's');
op.addOption("infoDevices", OPT_BOOL, "",
"show info for available platforms and devices", 'i');
op.addOption("verbose", OPT_BOOL, "", "enable verbose output", 'v');
op.addOption("quiet", OPT_BOOL, "", "write minimum necessary to standard output", 'q');
addBenchmarkSpecOptions(op);
if (!op.parse(argc, argv))
{
#ifdef PARALLEL
if (rank == 0)
op.usage();
MPI_Finalize();
#else
op.usage();
#endif
return (op.HelpRequested() ? 0 : 1 );
}
if (op.getOptionBool("infoDevices"))
{
#define DEBUG_DEVICE_CONTAINER 0
#ifdef PARALLEL
// execute following code only if I am the process of lowest
// rank on this node
NodeInfo NI;
int mynoderank = NI.nodeRank();
if (mynoderank==0)
{
int nlrrank, nlrsize;
MPI_Comm nlrcomm = NI.getNLRComm();
MPI_Comm_size(nlrcomm, &nlrsize);
MPI_Comm_rank(nlrcomm, &nlrrank);
OpenCLNodePlatformContainer ndc1;
OpenCLMultiNodeContainer localMnc(ndc1);
localMnc.doMerge (nlrrank, nlrsize, nlrcomm);
if (rank==0) // I am the global rank 0, print all configurations
localMnc.Print (cout);
}
#else
OpenCLNodePlatformContainer ndc1;
ndc1.Print (cout);
#if DEBUG_DEVICE_CONTAINER
OpenCLMultiNodeContainer mnc1(ndc1), mnc2;
mnc1.Print (cout);
ostringstream oss;
mnc1.writeObject (oss);
std::string temp(oss.str());
cout << "Serialized MultiNodeContainer:\n" << temp;
istringstream iss(temp);
mnc2.readObject (iss);
cout << "Unserialized object2:\n";
mnc2.Print (cout);
mnc1.merge (mnc2);
cout << "==============\nObject1 after merging 1:\n";
mnc1.Print (cout);
mnc1.merge (mnc2);
cout << "==============\nObject1 after merging 2:\n";
mnc1.Print (cout);
#endif // DEBUG
#endif // PARALLEL
return (0);
}
bool verbose = op.getOptionBool("verbose");
// The device option supports specifying more than one device
// for now, just choose the first one.
int platform = op.getOptionInt("platform");
#ifdef PARALLEL
NodeInfo ni;
int myNodeRank = ni.nodeRank();
if (verbose)
cout << "Global rank "<<rank<<" is local rank "<<myNodeRank << endl;
#else
int myNodeRank = 0;
#endif
// If they haven't specified any devices, assume they
// want the process with in-node rank N to use device N
int deviceIdx = myNodeRank;
// If they have, then round-robin the list of devices
// among the processes on a node.
vector<long long> deviceVec = op.getOptionVecInt("device");
if (deviceVec.size() > 0)
{
int len = deviceVec.size();
deviceIdx = deviceVec[myNodeRank % len];
}
// Check for an erroneous device
if (deviceIdx >= GetNumOclDevices(platform)) {
cerr << "Warning: device index: " << deviceIdx
<< " out of range, defaulting to device 0.\n";
deviceIdx = 0;
}
// Initialization
if (verbose) cout << ">> initializing\n";
cl_device_id devID = ListDevicesAndGetDevice(platform, deviceIdx);
cl_int clErr;
cl_context ctx = clCreateContext( NULL, // properties
1, // number of devices
&devID, // device
NULL, // notification function
NULL,
&clErr );
CL_CHECK_ERROR(clErr);
cl_command_queue queue = clCreateCommandQueue( ctx,
devID,
CL_QUEUE_PROFILING_ENABLE,
&clErr );
CL_CHECK_ERROR(clErr);
ResultDatabase resultDB;
// Run the benchmark
RunBenchmark(devID, ctx, queue, resultDB, op);
clReleaseCommandQueue( queue );
clReleaseContext( ctx );
#ifndef PARALLEL
resultDB.DumpDetailed(cout);
#else
ParallelResultDatabase pardb;
pardb.MergeSerialDatabases(resultDB,MPI_COMM_WORLD);
if (rank==0)
{
pardb.DumpSummary(cout);
pardb.DumpOutliers(cout);
}
#endif
}
catch( std::exception& e )
{
std::cerr << e.what() << std::endl;
ret = 1;
}
catch( ... )
{
std::cerr << "unrecognized exception caught" << std::endl;
ret = 1;
}
#ifdef PARALLEL
MPI_Finalize();
#endif
return ret;
}
int main(int argc, char *argv[])
{
int numdev=0, totalnumdev=0, numtasks, mympirank, dest, source, rc,
mypair=0, count, tag=2, mynoderank,myclusterrank,nodenprocs;
int *grp1, *grp2;
int mygrprank,grpnumtasks;
MPI_Group orig_group,bmgrp;
MPI_Comm bmcomm,nlrcomm;
ResultDatabase resultDB,resultDBWU,resultDB1;
OptionParser op;
ParallelResultDatabase pardb, pardb1;
bool amGPUTask = false;
volatile unsigned long long *mpidone;
int i,shmid;
/* Allocate System V shared memory */
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
MPI_Comm_rank(MPI_COMM_WORLD, &mympirank);
MPI_Comm_group(MPI_COMM_WORLD, &orig_group);
//Add shared options to the parser
op.addOption("device", OPT_VECINT, "0", "specify device(s) to run on",
'd');
op.addOption("verbose", OPT_BOOL, "", "enable verbose output", 'v');
op.addOption("quiet", OPT_BOOL, "",
"write minimum necessary to standard output", 'q');
op.addOption("passes", OPT_INT, "10", "specify number of passes", 'z');
op.addOption("size", OPT_VECINT, "1", "specify problem size", 's');
op.addOption("time", OPT_INT, "5", "specify running time in miuntes", 't');
op.addOption("outputFile", OPT_STRING, "output.txt", "specify output file",
'o');
op.addOption("infoDevices", OPT_BOOL, "", "show summary info for available devices",
'i');
op.addOption("fullInfoDevices", OPT_BOOL, "", "show full info for available devices");
op.addOption("MPIminmsg", OPT_INT, "0", "specify minimum MPI message size");
op.addOption("MPImaxmsg", OPT_INT, "16384",
"specify maximum MPI message size");
op.addOption("MPIiter", OPT_INT, "1000",
"specify number of MPI benchmark iterations for each size");
op.addOption("platform", OPT_INT, "0", "specify platform for device selection", 'y');
if (!op.parse(argc, argv))
{
if (mympirank == 0)
op.usage();
MPI_Finalize();
return 0;
}
int npasses = op.getOptionInt("passes");
//our simple mapping
NodeInfo NI;
mynoderank = NI.nodeRank(); // rank of my process within the node
myclusterrank = NI.clusterRank(); // cluster (essentially, node) id
MPI_Comm smpcomm = NI.getSMPComm();
if(mynoderank==0){
shmid = shmget(IPC_PRIVATE,
sizeof(unsigned long long),
(IPC_CREAT | 0600));
}
MPI_Bcast(&shmid, 1, MPI_INT, 0, NI.getSMPComm());
mpidone = ((volatile unsigned long long*) shmat(shmid, 0, 0));
if (mynoderank == 0)
shmctl(shmid, IPC_RMID, 0);
*mpidone = 0;
nlrcomm = NI.getNLRComm(); // communcator of all the lowest rank processes
// on all the nodes
int numnodes = NI.numNodes();
if ( numnodes%2!=0 )
{
if(mympirank==0)
printf("\nThis test needs an even number of nodes\n");
MPI_Finalize();
exit(0);
}
int nodealr = NI.nodeALR();
nodenprocs=NI.nodeNprocs();
// determine how many GPU devices we are to use
int devsPerNode = op.getOptionVecInt( "device" ).size();
//cout<<mympirank<<":numgpus="<<devsPerNode<<endl;
// if there are as many or more devices as the nprocs, only use half of
// the nproc
if ( devsPerNode >= nodenprocs ) devsPerNode = nodenprocs/2;
numdev = (mynoderank == 0) ? devsPerNode : 0;
MPI_Allreduce(&numdev, &totalnumdev, 1, MPI_INT, MPI_SUM,
MPI_COMM_WORLD);
numdev = devsPerNode;
// determine whether I am to be a GPU or a comm task
if( mynoderank < numdev )
{
amGPUTask = true;
}
//Divide tasks into two distinct groups based upon noderank
grp1=(int *)calloc(totalnumdev, sizeof(int));
grp2=(int *)calloc((numtasks-totalnumdev),sizeof(int));
if (grp1==NULL || grp2==NULL)
{
printf("\n%d:calloc failed in %s",mympirank,__FUNCTION__);
exit(1);
}
/*compute the groups*/
int beginoffset[2]={0,0};
if(mynoderank == 0)
{
int tmp[2];
tmp[0]=numdev;
tmp[1]=nodenprocs-numdev;
if (mympirank ==0)
MPI_Send(tmp, 2*sizeof(int), MPI_CHAR, 1, 112, nlrcomm);
else
{
MPI_Status reqstat;
MPI_Recv(beginoffset, 2*sizeof(int), MPI_CHAR, myclusterrank-1,
112, nlrcomm ,&reqstat);
if (myclusterrank < numnodes-1)
{
beginoffset[0]+=numdev;
beginoffset[1]+=(nodenprocs-numdev);
MPI_Send(beginoffset,2*sizeof(int), MPI_CHAR, myclusterrank+1,
112, nlrcomm);
beginoffset[0]-=numdev;
beginoffset[1]-=(nodenprocs-numdev);
}
}
}
MPI_Bcast(beginoffset,2,MPI_INT,0,smpcomm);
if ( amGPUTask )
{
// I am to do GPU work
grp1[beginoffset[0]+mynoderank]=mympirank;
grpnumtasks=totalnumdev;
}
else
{
// I am to do MPI communication work
grp2[beginoffset[1]+(mynoderank-numdev)]=mympirank;
grpnumtasks=numtasks-totalnumdev;
}
MPI_Allreduce(MPI_IN_PLACE, grp1, totalnumdev, MPI_INT, MPI_SUM,
MPI_COMM_WORLD);
MPI_Allreduce(MPI_IN_PLACE, grp2, (numtasks-totalnumdev), MPI_INT,
MPI_SUM, MPI_COMM_WORLD);
if ( amGPUTask )
{
// I am to do GPU work, so will be part of GPU communicator
MPI_Group_incl(orig_group, totalnumdev, grp1, &bmgrp);
}
else
{
// I am to do MPI communication work, so will be part of MPI
// messaging traffic communicator
MPI_Group_incl(orig_group, (numtasks-totalnumdev), grp2,
&bmgrp);
}
MPI_Comm_create(MPI_COMM_WORLD, bmgrp, &bmcomm);
MPI_Comm_rank(bmcomm, &mygrprank);
NodeInfo *GRPNI = new NodeInfo(bmcomm);
int mygrpnoderank=GRPNI->nodeRank();
int grpnodealr = GRPNI->nodeALR();
int grpnodenprocs = GRPNI->nodeNprocs();
MPI_Comm grpnlrcomm = GRPNI->getNLRComm();
//note that clusterrank and number of nodes don't change for this child
//group/comm
//form node-random pairs (see README) among communication tasks
if( amGPUTask )
{
//setup GPU in GPU tasks
GPUSetup(op, mympirank, mynoderank);
}
else
{
int * pairlist = new int[numnodes];
for (i=0;i<numnodes;i++) pairlist[i]=0;
if ( mygrpnoderank==0 )
{
pairlist[myclusterrank]=grpnodealr;
MPI_Allreduce(MPI_IN_PLACE,pairlist,numnodes,MPI_INT,MPI_SUM,
grpnlrcomm);
mypair = RandomPairs(myclusterrank, numnodes, grpnlrcomm);
mypair = pairlist[mypair];
}
for (i=0;i<numnodes;i++) pairlist[i]=0;
if ( mygrpnoderank==0 )
pairlist[myclusterrank]=mypair;
MPI_Allreduce(MPI_IN_PLACE,pairlist,numnodes,MPI_INT,MPI_SUM,
bmcomm);
mypair = pairlist[myclusterrank]+mygrpnoderank;
}
// ensure we are all synchronized before starting test
MPI_Barrier(MPI_COMM_WORLD);
//warmup run
if ( amGPUTask )
{
GPUDriver(op, resultDBWU);
}
//first, individual runs for device benchmark
for(i=0;i<npasses;i++){
if ( amGPUTask )
{
GPUDriver(op, resultDB);
}
}
MPI_Barrier(MPI_COMM_WORLD);
//warmup run
if ( !amGPUTask )
{
MPITest(op, resultDBWU, grpnumtasks, mygrprank, mypair, bmcomm);
}
//next, individual run for MPI Benchmark
for(i=0;i<npasses;i++){
if ( !amGPUTask )
{
MPITest(op, resultDB, grpnumtasks, mygrprank, mypair, bmcomm);
}
}
MPI_Barrier(MPI_COMM_WORLD);
//merge and print
pardb.MergeSerialDatabases(resultDB, bmcomm);
if (mympirank==0)
cout<<endl<<"*****************************Sequential GPU and MPI runs****************************"<<endl;
DumpInSequence(pardb, mygrprank, mympirank);
// Simultaneous runs for observing impact of contention
MPI_Barrier(MPI_COMM_WORLD);
if ( amGPUTask )
{
do {
if (mympirank == 0 ) cout<<".";
GPUDriver(op, resultDB1);flush(cout);
} while(*mpidone==0);
if (mympirank == 0 ) cout<<"*"<<endl;
}
else
{
for ( i=0;i<npasses;i++ )
{
MPITest(op, resultDB1, grpnumtasks, mygrprank, mypair, bmcomm);
}
*mpidone=1;
}
MPI_Barrier(MPI_COMM_WORLD);
//merge and print
pardb1.MergeSerialDatabases(resultDB1,bmcomm);
if (mympirank==0)
cout<<endl<<"*****************************Simultaneous GPU and MPI runs****************************"<<endl;
DumpInSequence(pardb1, mygrprank, mympirank);
//print summary
if ( !amGPUTask && mygrprank==0)
{
vector<ResultDatabase::Result> prelatency = pardb.GetResultsForTest("MPI Latency(mean)");
vector<ResultDatabase::Result> postlatency = pardb1.GetResultsForTest("MPI Latency(mean)");
cout<<endl<<"Summarized Mean(Mean) MPI Baseline Latency vs. Latency with Contention";
cout<<endl<<"MSG SIZE(B)\t";
int msgsize=0;
for (i=0; i<prelatency.size(); i++)
{
cout<<msgsize<<"\t";
msgsize = (msgsize ? msgsize * 2 : msgsize + 1);
}
cout << endl <<"BASELATENCY\t";
for (i=0; i<prelatency.size(); i++)
cout<<setiosflags(ios::fixed) << setprecision(2)<<prelatency[i].GetMean() << "\t";
cout << endl <<"CONTLATENCY\t";
for (i=0; i<postlatency.size(); i++)
cout<<setiosflags(ios::fixed) << setprecision(2)<<postlatency[i].GetMean() << "\t";
flush(cout);
cout<<endl;
}
MPI_Barrier(MPI_COMM_WORLD);
if ( amGPUTask && mympirank==0)
{
vector<ResultDatabase::Result> prespeed = pardb.GetResultsForTest("DownloadSpeed(mean)");
vector<ResultDatabase::Result> postspeed = pardb1.GetResultsForTest("DownloadSpeed(mean)");
cout<<endl<<"Summarized Mean(Mean) GPU Baseline Download Speed vs. Download Speed with Contention";
cout<<endl<<"MSG SIZE(KB)\t";
int msgsize=1;
for (i=0; i<prespeed.size(); ++i)
{
cout<<msgsize<<"\t";
msgsize = (msgsize ? msgsize * 2 : msgsize + 1);
}
cout << endl <<"BASESPEED\t";
for (i=0; i<prespeed.size(); ++i)
cout<<setiosflags(ios::fixed) << setprecision(4)<<prespeed[i].GetMean() << "\t";
cout << endl <<"CONTSPEED\t";
for (i=0; i<postspeed.size(); ++i)
cout<<setiosflags(ios::fixed) << setprecision(4)<<postspeed[i].GetMean() << "\t";
cout<<endl;
}
if ( amGPUTask && mympirank==0)
{
vector<ResultDatabase::Result> pregpulat = pardb.GetResultsForTest("DownloadLatencyEstimate(mean)");
vector<ResultDatabase::Result> postgpulat = pardb1.GetResultsForTest("DownloadLatencyEstimate(mean)");
cout<<endl<<"Summarized Mean(Mean) GPU Baseline Download Latency vs. Download Latency with Contention";
cout<<endl<<"MSG SIZE\t";
for (i=0; i<pregpulat.size(); ++i)
{
cout<<pregpulat[i].atts<<"\t";
}
cout << endl <<"BASEGPULAT\t";
for (i=0; i<pregpulat.size(); ++i)
cout<<setiosflags(ios::fixed) << setprecision(7)<<pregpulat[i].GetMean() << "\t";
cout << endl <<"CONTGPULAT\t";
for (i=0; i<postgpulat.size(); ++i)
cout<<setiosflags(ios::fixed) << setprecision(7)<<postgpulat[i].GetMean() << "\t";
cout<<endl;
}
//cleanup GPU
if( amGPUTask )
{
GPUCleanup(op);
}
MPI_Finalize();
}
int main ( int argc, char **argv )
{
string appName ( argv[0] );
string appExample ( "partitionConfigFile outputBaseName [ options] \
\n\nDetails:\n\
\tthis program reads a series of connectivity pattern files, and trains a connectomic profile for each ROI\n\
\tpartitionConfigFile contains the names of output from the pipeline.\n\
\tgrpProfile is the output for resultant profiles, written in arma format\n" );
Option<bool> helpOpt ( string ( "-h" ),false,string ( "display this help information. " ),false,no_argument );
Option<int> modeOpt ( "--mode",3,"the mode of engergy functions, e.g., L1COEFFS(0), L2ERROR(1), PENALTY(2), SPARSITY(3), L2ERROR2(4), PENALTY2(5), default: 3", false, requires_argument );
Option<int> modeDOpt ( "--modeD",3,"the constraints on dictionary: L2(0), L1L2(1), L1L2FL(2), L1L2MU(3), default: 3",false,requires_argument );
Option<int> modePOpt ( "--modeP",0,"the method to minimization: AUTO(0), PARAM1(1), PARAM2(2), PARAM3(3), default: 0",false,requires_argument );
Option<float> lambdaOpt ( "--lamda",1," lambda, default: 1", false,requires_argument );
Option<float> lambda2Opt ( "--lamda2", 0.15, "lambda2, default: 0", false,requires_argument );
Option<float> gamma1Opt ( "--gamma1",0.4,"gamma1, default:0.4",false,requires_argument );
Option<float> gamma2Opt ( "--gamma2",0,"gamma2, default:0",false,requires_argument );
Option<bool> posAlphaOpt ( "--posAlpha",true,"where or not constrain alpha to be positive, default: true",false,no_argument );
Option<bool> posDOpt ( "--posD",false,"whether or not constrain Dictionary to be positive, default: false",false,no_argument );
Option<int> iterOpt ( "--iter", 300,"the number of iteration, default: 300",false,requires_argument );
Option<bool> verboseOpt ( "-v",false,"verbose or not,default, false",false,no_argument );
Option<int> numDicOpt ( "-K",5,"the number of dic elems, default: 5",false,requires_argument );
Option<int> batchSizeOpt ( "-b",30,"the number of batch, default: 30", false,requires_argument );
Option<string> aplibFullNameOpt ( "--aplib","/home/kli/bin/apclusterunix64.so","the full path name of ap lib;", false,requires_argument );
Option<float> prefrenceOpt ( "-p",0,"the prefrence of ap clustering, if not set, will use mean similarity.", false,requires_argument );
Option<string> leftPartCenterSphereOpt ( "--leftParts","lh.resx.200.CentersonSphere.vtk","the name of left part centers at reg space, default: lh.parts.200.CentersonSphere.vtk",false,requires_argument );
Option<string> rightPartCenterSphereOpt ( "--rightParts","rh.resx.200.CentersonSphere.vtk","the name of right part centers at reg space, default: rh.parts.200.CentersonSphere.vtk",false,requires_argument );
Option<string> leftLabelMatchAtSubjOpt ( "--leftMatch","labelMatch.lh.resx.200.tmplAtSubj", "the name of left label match for tmpl at subject space, default: labelMatch.lh.resx.200.tmplAtSubj", false,requires_argument );
Option<string> rightLabelMatchAtSubjOpt ( "--rightMatch","labelMatch.rh.resx.200.tmplAtSubj", "the name of right label match for tmpl at subject space, default: labelMatch.rh.resx.200.tmplAtSubj", false,requires_argument );
Option<string> subjDirsListOpt ( "-L","","the list of allReg directory for subjects, no default, must be set", true, requires_argument );
OptionParser cmdParser ( appName,appName+"\t"+appExample );
cmdParser.add ( helpOpt );
cmdParser.add ( verboseOpt );
cmdParser.add ( numDicOpt );
cmdParser.add ( batchSizeOpt );
cmdParser.add ( prefrenceOpt );
cmdParser.add ( modeOpt );
cmdParser.add ( modePOpt );
cmdParser.add ( modeDOpt );
cmdParser.add ( lambdaOpt );
cmdParser.add ( lambda2Opt );
cmdParser.add ( gamma2Opt );
cmdParser.add ( gamma1Opt );
cmdParser.add ( posDOpt );
cmdParser.add ( posAlphaOpt );
cmdParser.add ( iterOpt );
cmdParser.add ( aplibFullNameOpt );
cmdParser.add ( leftLabelMatchAtSubjOpt );
cmdParser.add ( rightLabelMatchAtSubjOpt );
cmdParser.add ( leftPartCenterSphereOpt );
cmdParser.add ( rightPartCenterSphereOpt );
cmdParser.add ( subjDirsListOpt );
cmdParser.parse_command_line ( argc,argv,2 );
if ( 3 > argc || cmdParser.check_compulsory_arguments ( true ) == false ) {
cmdParser.usage();
exit ( EXIT_FAILURE );
}
//set up parameters for dic learning;
ParamDictLearn<float> parameters;
parameters.mode = SPAMS::constraint_type ( modeOpt.value() );
parameters.posAlpha = posAlphaOpt.value();
parameters.lambda= lambdaOpt.value();
parameters.modeD=SPAMS::constraint_type_D ( modeDOpt.value() );
parameters.gamma1=gamma1Opt.value();
parameters.modeParam=SPAMS::mode_compute ( modePOpt.value() );
parameters.gamma2 = gamma2Opt.value(); // for modeD=2;
parameters.iter=iterOpt.value();
parameters.verbose=verboseOpt.value();
//setup input connectivity files;
vector<string> allConfigNames;
KML::ReadNameList(argv[1],allConfigNames);
CfMRIDicccol objfMRIDicccol;
objfMRIDicccol.SetConnectivityFileName(allConfigNames[8]);
objfMRIDicccol.SetNames4TmplLabelMatchAtSubj ( allConfigNames[6],allConfigNames[7]);
objfMRIDicccol.SetNames4PartitionCenterSurfAtRegSpace ( allConfigNames[10],allConfigNames[11] );
objfMRIDicccol.SetData ( subjDirsListOpt.value() );
objfMRIDicccol.SetParamDicLearn ( parameters );
objfMRIDicccol.SetTrainer ( numDicOpt.value(),batchSizeOpt.value(),-1 );
objfMRIDicccol.LearnProfileAndCoordModels();
objfMRIDicccol.SaveProfileAndCoordModels ( argv[2] );
//now clustering profiles;
list<int> v1,v2;
list<float> sims;
float meanSim = objfMRIDicccol.ComputeSims4Profiles ( v1,v2,sims,string ( argv[2] ) +".cluster.sims" );
CAPClustering apc;
apc.SetNPoints ( objfMRIDicccol.GetNROIs() );
apc.SetAplibName ( aplibFullNameOpt.value() );
apc.SetMaxIteration ( 4000 );
apc.SetPreference ( prefrenceOpt.set() ? prefrenceOpt.value() : meanSim );
apc.Clustering ( v1,v2,sims );
std::vector< int > idx=apc.GetClusterResultIdx();
std::vector< int > centers=apc.GetCenters();
ivec armaIdx ( &idx[0],idx.size() );
armaIdx.save ( string ( argv[2] ) +".cluster.idx" );
return 0;
} //end of main function;
int
main(int argc, char** argv)
{
OptionParser options;
options.executable("dune-test-tail")
.program(DUNE_SHORT_NAME)
.copyright(DUNE_COPYRIGHT)
.email(DUNE_CONTACT)
.version(getFullVersion())
.date(getCompileDate())
.arch(DUNE_SYSTEM_NAME)
.add("-i", "--address",
"Vehicle's IP address", "ADDRESS")
.add("-w", "--wait",
"Wait DELAY seconds before starting test", "DELAY")
.add("-d", "--duration",
"Test duration in seconds", "DURATION")
.add("-s", "--speed",
"Speed in percentage", "SPEED")
.add("-t", "--angle",
"Angle in degrees", "ANGLE");
// Parse command line arguments.
if (!options.parse(argc, argv))
{
if (options.bad())
std::cerr << "ERROR: " << options.error() << std::endl;
options.usage();
return 1;
}
// Set destination address.
if (options.value("--address") == "")
g_addr = "127.0.0.1";
else
g_addr = options.value("--address").c_str();
// Set start delay.
double sdelay = 0;
if (options.value("--wait") == "")
sdelay = 0;
else
sdelay = castLexical<double>(options.value("--wait"));
// Set duration.
double duration = 0;
if (options.value("--duration") == "")
duration = 0;
else
duration = castLexical<double>(options.value("--duration"));
// Set speed.
double speed = 0;
if (options.value("--speed") == "")
speed = 0;
else
{
speed = castLexical<double>(options.value("--speed"));
speed /= 100.0;
}
// Set Angle
double angle = 0;
if (options.value("--angle") == "")
angle = 0;
else
angle = castLexical<double>(options.value("--angle"));
// POSIX implementation.
#if defined(DUNE_SYS_HAS_SIGACTION)
struct sigaction actions;
std::memset(&actions, 0, sizeof(actions));
sigemptyset(&actions.sa_mask);
actions.sa_flags = 0;
actions.sa_handler = handleTerminate;
sigaction(SIGALRM, &actions, 0);
sigaction(SIGHUP, &actions, 0);
sigaction(SIGINT, &actions, 0);
sigaction(SIGQUIT, &actions, 0);
sigaction(SIGTERM, &actions, 0);
sigaction(SIGCHLD, &actions, 0);
sigaction(SIGCONT, &actions, 0);
#endif
setThrust(0);
Delay::wait(sdelay);
setLog("mcrt_endurance");
Delay::wait(2.0);
double deadline = Clock::get() + duration;
setThrust(speed);
while ((Clock::get() < deadline) && !g_stop)
{
setFin(0, -angle);
setFin(1, -angle);
setFin(2, -angle);
setFin(3, -angle);
if (!g_stop)
Delay::wait(1.0);
if (!g_stop)
Delay::wait(1.0);
if (!g_stop)
Delay::wait(1.0);
if (!g_stop)
Delay::wait(1.0);
setFin(0, angle);
setFin(1, angle);
setFin(2, angle);
setFin(3, angle);
if (!g_stop)
Delay::wait(1.0);
if (!g_stop)
Delay::wait(1.0);
if (!g_stop)
Delay::wait(1.0);
if (!g_stop)
Delay::wait(1.0);
}
// Change log.
Delay::wait(2.0);
setLog("idle");
onTerminate();
return 0;
}
// ****************************************************************************
// Function: main
//
// Purpose:
// The main function takes care of initialization (device and MPI), then
// performs the benchmark and prints results.
//
// Arguments:
//
//
// Programmer: Jeremy Meredith
// Creation:
//
// Modifications:
// Jeremy Meredith, Wed Nov 10 14:20:47 EST 2010
// Split timing reports into detailed and summary. For serial code, we
// report all trial values, and for parallel, skip the per-process vals.
// Also detect and print outliers from parallel runs.
//
// ****************************************************************************
int main(int argc, char *argv[])
{
int ret = 0;
bool noprompt = false;
try
{
#ifdef PARALLEL
int rank, size;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
cerr << "MPI Task " << rank << "/" << size - 1 << " starting....\n";
#endif
// Get args
OptionParser op;
//Add shared options to the parser
op.addOption("device", OPT_VECINT, "0",
"specify device(s) to run on", 'd');
op.addOption("verbose", OPT_BOOL, "", "enable verbose output", 'v');
op.addOption("passes", OPT_INT, "10", "specify number of passes", 'n');
op.addOption("size", OPT_INT, "1", "specify problem size", 's');
op.addOption("infoDevices", OPT_BOOL, "",
"show info for available platforms and devices", 'i');
op.addOption("quiet", OPT_BOOL, "", "write minimum necessary to standard output", 'q');
#ifdef _WIN32
op.addOption("noprompt", OPT_BOOL, "", "don't wait for prompt at program exit");
#endif
addBenchmarkSpecOptions(op);
if (!op.parse(argc, argv))
{
#ifdef PARALLEL
if (rank == 0)
op.usage();
MPI_Finalize();
#else
op.usage();
#endif
return (op.HelpRequested() ? 0 : 1);
}
bool verbose = op.getOptionBool("verbose");
bool infoDev = op.getOptionBool("infoDevices");
#ifdef _WIN32
noprompt = op.getOptionBool("noprompt");
#endif
int device;
#ifdef PARALLEL
NodeInfo ni;
int myNodeRank = ni.nodeRank();
vector<long long> deviceVec = op.getOptionVecInt("device");
if (myNodeRank >= deviceVec.size()) {
// Default is for task i to test device i
device = myNodeRank;
} else {
device = deviceVec[myNodeRank];
}
#else
device = op.getOptionVecInt("device")[0];
#endif
int deviceCount;
cudaGetDeviceCount(&deviceCount);
if (device >= deviceCount) {
cerr << "Warning: device index: " << device <<
" out of range, defaulting to device 0.\n";
device = 0;
}
// Initialization
EnumerateDevicesAndChoose(device, infoDev);
if( infoDev )
{
return 0;
}
ResultDatabase resultDB;
// Run the benchmark
RunBenchmark(resultDB, op);
#ifndef PARALLEL
resultDB.DumpDetailed(cout);
#else
ParallelResultDatabase pardb;
pardb.MergeSerialDatabases(resultDB,MPI_COMM_WORLD);
if (rank==0)
{
pardb.DumpSummary(cout);
pardb.DumpOutliers(cout);
}
#endif
}
catch( InvalidArgValue& e )
{
std::cerr << e.what() << ": " << e.GetMessage() << std::endl;
ret = 1;
}
catch( std::exception& e )
{
std::cerr << e.what() << std::endl;
ret = 1;
}
catch( ... )
{
ret = 1;
}
#ifdef PARALLEL
MPI_Finalize();
#endif
#ifdef _WIN32
if (!noprompt)
{
cout << "Press return to exit\n";
cin.get();
}
#endif
return ret;
}
int
main(int argc, char** argv)
{
Tasks::Context context;
I18N::setLanguage(context.dir_i18n);
Scheduler::set(Scheduler::POLICY_RR);
OptionParser options;
options.executable("dune")
.program(DUNE_SHORT_NAME)
.copyright(DUNE_COPYRIGHT)
.email(DUNE_CONTACT)
.version(getFullVersion())
.date(getCompileDate())
.arch(DUNE_SYSTEM_NAME)
.add("-d", "--config-dir",
"Configuration directory", "DIR")
.add("-w", "--www-dir",
"HTTP server base directory", "DIR")
.add("-c", "--config-file",
"Load configuration file CONFIG", "CONFIG")
.add("-m", "--lock-memory",
"Lock memory")
.add("-p", "--profiles",
"Execution Profiles", "PROFILES")
.add("-V", "--vehicle",
"Vehicle name override", "VEHICLE")
.add("-X", "--dump-params-xml",
"Dump parameters XML to folder DIR", "DIR");
// Parse command line arguments.
if (!options.parse(argc, argv))
{
if (options.bad())
std::cerr << "ERROR: " << options.error() << std::endl;
options.usage();
return 1;
}
// If requested, lock memory.
if (!options.value("--lock-memory").empty())
{
#if defined(DUNE_USING_TLSF) && defined(DUNE_CLIB_GNU)
Resources::lockMemory(c_memory, c_memory_size);
#else
Resources::lockMemory();
#endif
}
// If requested, set alternate configuration directory.
if (options.value("--config-dir") != "")
{
context.dir_cfg = options.value("--config-dir");
}
// If requested, set alternate HTTP server directory.
if (options.value("--www-dir") != "")
{
context.dir_www = options.value("--www-dir");
}
DUNE::Tasks::Factory::registerDynamicTasks(context.dir_lib.c_str());
registerStaticTasks();
// Retrieve configuration file and try parsing it.
if (options.value("--config-file") == "")
{
std::cerr << String::str(DTR("ERROR: no configuration file was given, "
"see options --config-list and --config-file\n"))
<< std::endl;
return 1;
}
Path cfg_file = context.dir_cfg / options.value("--config-file") + ".ini";
try
{
context.config.parseFile(cfg_file.c_str());
}
catch (std::runtime_error& e)
{
try
{
cfg_file = context.dir_usr_cfg / options.value("--config-file") + ".ini";
context.config.parseFile(cfg_file.c_str());
context.dir_cfg = context.dir_usr_cfg;
}
catch (std::runtime_error& e2)
{
std::cerr << String::str("ERROR: %s\n", e.what()) << std::endl;
std::cerr << String::str("ERROR: %s\n", e2.what()) << std::endl;
return 1;
}
}
if (!options.value("--vehicle").empty())
context.config.set("General", "Vehicle", options.value("--vehicle"));
try
{
DUNE::Daemon daemon(context, options.value("--profiles"));
// Parameters XML.
if (options.value("--dump-params-xml") != "")
{
std::string lang = I18N::getLanguage();
std::string file = String::str("%s.%s.xml", daemon.getSystemName(), lang.c_str());
Path path = Path(options.value("--dump-params-xml")) / file;
std::ofstream ofs(path.c_str());
if (!ofs.is_open())
{
std::cerr << "ERROR: failed to create file '" << path << "'" << std::endl;
return 1;
}
daemon.writeParamsXML(ofs);
return 0;
}
return runDaemon(daemon);
}
catch (std::exception& e)
{
std::cerr << "ERROR: " << e.what() << std::endl;
}
}
int
main(int argc, char** argv)
{
OptionParser options;
options.executable(argv[0])
.program("DUNE UCTK Flash Programmer")
.copyright(DUNE_COPYRIGHT)
.email("Ricardo Martins <*****@*****.**>")
.version(getFullVersion())
.date(getCompileDate())
.arch(DUNE_SYSTEM_NAME)
.description("Utility to update the firmware of UCTK based devices.")
.add("-d", "--dev",
"System device", "DEVICE")
.add("-t", "--dev-type",
"System device type", "TYPE")
.add("-f", "--file",
"iHEX file", "IHEX_FILE");
// Parse command line arguments.
if (!options.parse(argc, argv))
{
if (options.bad())
std::cerr << "ERROR: " << options.error() << std::endl;
options.usage();
return 1;
}
// Get iHEX file.
std::string ihex = options.value("--file");
if (ihex.empty())
{
std::cerr << "ERROR: you must specify one iHEX file." << std::endl;
return 1;
}
if (Path(ihex).type() != Path::PT_FILE)
{
std::cerr << "ERROR: no such file: '" << ihex << "'" << std::endl;
return 1;
}
// Get system device.
std::string sys_dev = options.value("--dev");
if (sys_dev.empty())
{
std::cerr << "ERROR: you must specify one system device." << std::endl;
return 1;
}
// Get device type.
IO::Handle* handle = NULL;
std::string dev_type = options.value("--dev-type");
if (dev_type == "escc")
handle = new ESCC(sys_dev);
else
handle = new SerialPort(sys_dev, c_baud_rate);
UCTK::Interface itf(handle);
UCTK::Bootloader* boot = new UCTK::Bootloader(&itf, true);
boot->program(ihex);
delete boot;
delete handle;
return 0;
}
