void Console::execute( const std::string& line )
{
std::clog << ">";
pushLine( line );
std::string::size_type pos = line.find( ' ' );
std::string cmd = std::string( line.begin(), pos != std::string::npos ? line.begin() + pos : line.end() );
auto find = std::find_if( m_cmds.begin(), m_cmds.end(), std::bind( &con::Command::operator==, std::placeholders::_1, cmd ) );
try
{
if ( find == m_cmds.end() )
throw UnknownCommandException();
(**find)( *this, parseArguments( pos != std::string::npos ? std::string( line.begin() + pos + 1, line.end() ) : "" ) );
}
catch ( std::exception& err )
{
*this << con::setcerr << err.what() << con::endl;
}
}
int init(int argc, char **args) {
puts("Start Server...");
char *port;
puts("Parse Arguments from console...");
if (parseArguments(argc, args, &port) == EXIT_FAILURE)
return EXIT_FAILURE;
puts("Initiating connection...");
if (initConnection(port) == EXIT_FAILURE)
return EXIT_FAILURE;
if (initPoll() == EXIT_FAILURE) {
return EXIT_FAILURE;
}
clientList = clientVector_construct(8);
printf("Gnuddels-Server started on the port %s!\n", port);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
const char* fmuFileName;
int i;
// parse command line arguments and load the FMU
// default arguments value
double tEnd = 1.0;
double h=0.1;
int loggingOn = 0;
char csv_separator = ',';
fmi2String *categories = NULL;
int nCategories = 0;
parseArguments(argc, argv, &fmuFileName, &tEnd, &h, &loggingOn, &csv_separator, &nCategories, &categories);
loadFMU(fmuFileName);
// run the simulation
printf("FMU Simulator: run '%s' from t=0..%g with step size h=%g, loggingOn=%d, csv separator='%c' ",
fmuFileName, tEnd, h, loggingOn, csv_separator);
printf("log categories={ ");
for (i = 0; i < nCategories; i++) printf("%s ", categories[i]);
printf("}\n");
simulate(&fmu, tEnd, h, loggingOn, csv_separator, nCategories, categories);
printf("CSV file '%s' written\n", RESULT_FILE);
// release FMU
#ifdef _MSC_VER
FreeLibrary(fmu.dllHandle);
#else
dlclose(fmu.dllHandle);
#endif
freeModelDescription(fmu.modelDescription);
//if (categories) free(categories);
// delete temp files obtained by unzipping the FMU
deleteUnzippedFiles();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Q_INIT_RESOURCE(bauhaus);
doStyling(app);
#ifdef Q_WS_X11
QIcon applicationIcon;
applicationIcon.addFile(":/16xBauhaus_Log");
applicationIcon.addFile(":/64xBauhaus_Logo.png");
applicationIcon.addFile(":/128xBauhaus_Logo.png");
applicationIcon.addFile(":/256xBauhaus_Logo.png");
Q_ASSERT(!applicationIcon.isNull());
app.setWindowIcon(applicationIcon);
#endif
QCoreApplication::setOrganizationName("Nokia");
QCoreApplication::setOrganizationDomain("nokia.com");
QCoreApplication::setApplicationName("Bauhaus");
try {
QmlDesigner::IntegrationCore core;
core.pluginManager()->setPluginPaths(pluginPaths());
MainWindow mainWindow;
mainWindow.show();
parseArguments(app.arguments(), mainWindow);
// if (mainWindow.documentCount() == 0)
// mainWindow.showWelcomeScreen();
//
return app.exec();
} catch (const QmlDesigner::Exception &exception) {
qWarning() << exception;
return -1;
}
}
int main(int argc, char *argv[]) {
FILE *f;
extern void initGlobalStructure(void);
extern void setMetaKeyOptions(int swap);
parseArguments( argv, argc, args);
if (versionMe) versionMessage(vmPath);
if (helpMe) helpMessage(vmPath, "!Help");
atexit(exit_function); // setup a clean exit function
InitRiscOS();
initGlobalStructure();
dummyWimpPoll();
/* read the image file and allocate memory for Squeak heap */
f = fopen(imageName, "rb");
PRINTF(("\\t Starting Squeak with image file: %s\n", imageName));
if (f == NULL) {
/* give a RPC error message if image file is not found */
extern char VMVersion[];
privateErr.errnum = (bits)0;
sprintf(privateErr.errmess, "Could not open the Squeak image file '%s' (Squeak version: %s)", imageName, VMVersion);
printf("%s\n", privateErr.errmess);
platReportError((os_error *)&privateErr);
helpMessage(vmPath, "!ImName");
ioExit();
}
setMetaKeyOptions(swapMeta);
readImageFromFileHeapSize(f, objectHeadroom);
fclose(f);
/* run Squeak */
PRINTF(("\\t start running image\n"));
interpret();
}
static void
initialize(int argc, char *argv[], int offset) {
int e, fd;
parseArguments(argc, argv, offset);
if (logFile != NULL) {
fd = open(logFile, O_WRONLY | O_APPEND | O_CREAT, 0644);
if (fd == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot open log file %s for writing: %s (errno %d)\n",
logFile, strerror(e), e);
exit(1);
}
if (dup2(fd, 1) == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot dup2(%d, 1): %s (errno %d)\n",
fd, strerror(e), e);
}
if (dup2(fd, 2) == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot dup2(%d, 2): %s (errno %d)\n",
fd, strerror(e), e);
}
close(fd);
}
if (pipe(terminationPipe) == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot create a pipe: %s (errno %d)\n",
strerror(e), e);
exit(1);
}
setNonBlocking(terminationPipe[1]);
}
static boolean parseFeature (tokenInfo *const token)
{
boolean found = FALSE;
while (readFeatureName (token))
{
found = TRUE;
makeEiffelFeatureTag (token);
readToken (token);
if (isType (token, TOKEN_COMMA))
readToken (token);
}
if (found)
{
if (isKeyword (token, KEYWORD_alias)) {
readToken (token);
if (isType (token, TOKEN_STRING))
makeEiffelFeatureTag (token);
readToken (token);
}
if (isType (token, TOKEN_OPEN_PAREN)) /* arguments? */
parseArguments (token);
if (isType (token, TOKEN_COLON)) /* a query? */
parseEntityType (token);
if (isKeyword (token, KEYWORD_assign))
{
readToken (token);
readToken (token);
}
if (isKeyword (token, KEYWORD_obsolete))
{
readToken (token);
if (isType (token, TOKEN_STRING))
readToken (token);
}
findFeatureEnd (token);
}
return found;
}
int main (int argc, char **argv)
{
bool pass = true;
static size_t n = 20;
//static integer q = 65519; problem
//static integer q = 1009;
//static integer q = 1000003;
static integer q = 46337;
static int iterations = 1;
static double sparsity = 0.05;
static Argument args[] = {
{ 'n', "-n N", "Set dimension of test matrices to NxN.", TYPE_INT, &n },
{ 'q', "-q Q", "Operate over the \"field\" GF(Q) [1].", TYPE_INTEGER, &q },
{ 'i', "-i I", "Perform each test for I iterations.", TYPE_INT, &iterations },
{ 's', "-s S", "Sparse matrices with density S.", TYPE_DOUBLE, &sparsity },
END_OF_ARGUMENTS
};
parseArguments (argc, argv, args);
srand ((unsigned)time (NULL));
// srand48 ((unsigned)time (NULL));
commentator().start("Givaro::Modular<uint32_t,uint64_t> sparse rank test suite", "rank");
commentator().getMessageClass (INTERNAL_DESCRIPTION).setMaxDepth (3);
commentator().getMessageClass (INTERNAL_DESCRIPTION).setMaxDetailLevel (Commentator::LEVEL_NORMAL);
Givaro::Modular<uint32_t,uint64_t> F (q);
pass = pass && testSparseRank(F,n,n+1,(size_t)iterations,sparsity);
pass = pass && testSparseRank(F,LINBOX_USE_BLACKBOX_THRESHOLD+n,LINBOX_USE_BLACKBOX_THRESHOLD+n-1,(size_t)iterations,sparsity);
commentator().stop("Givaro::Modular<uint32_t,uint64_t> sparse rank test suite");
return pass ? 0 : -1;
}
int main(int argc, char* argv[]) {
Matrix matrix;
/*Read in height and width*/
parseArguments(argc, argv, &matrix);
/*Allocate matrix on the heap*/
initMatrix(&matrix);
/*Fill with random unsigned chars*/
fillRandomData(&matrix);
/*Start timer*/
double start,mid1, mid2, end;
start = (double) clock();
/*Differentiate*/
int** dx = differentiateX(&matrix);
mid1 = (double) clock();
int** dy = differentiateY(&matrix);
mid2 = (double) clock();
/*Compute min and max*/
printf("The max and min for dx are: %d and %d\n", max(dx, matrix.width, matrix.height), min(dx, matrix.width, matrix.height));
printf("The max and min for dy are: %d and %d\n", max(dy, matrix.width, matrix.height), min(dy, matrix.width, matrix.height));
/*End timer*/
end = (double) clock();
printf("Total time taken: %.4f msec\n", (end-start) / CLOCKS_PER_MSEC);
printf("dx takes %f, dy takes %f msec\n", (mid1 - start) / CLOCKS_PER_MSEC, (mid2 - mid1) / CLOCKS_PER_MSEC);
/*Print*/
/*printMatrix(&matrix);*/
/*printArray(dx, matrix.width, matrix.height);*/
/*printArray(dy, matrix.width, matrix.height);*/
/*Free everything*/
for (int x = 0; x < matrix.width; x++) {
free(matrix.data[x]);
free(dx[x]);
free(dy[x]);
}
free(matrix.data);
free(dx);
free(dy);
return 0;
}
int main(int argc, char **argv)
{
switch (parseArguments(argc, argv))
{
case CommandTypes::None:
return RET_OK;
case CommandTypes::Invalid:
return RET_FAIL_ARGS;
case CommandTypes::Run:
return Run();
case CommandTypes::Compile:
case CommandTypes::CompileNative:
return Compile();
case CommandTypes::CompileAndRun:
return CompileAndRun();
}
return RET_OK;
}
/*!
Uses application's arguments (\a appArguments) to initialise
QWsdl Flags and itself, and \a parent to construct the object.
*/
WsdlConverter::WsdlConverter(const QStringList &appArguments, QObject *parent) :
QObject(parent)
{
flags = new Flags();
argList = new QMap<int, QVariant>();
// Dummy wsdl to prevent segfaulting when parsing arguments fails.
wsdl = new QWsdl(this);
errorState = false;
// errorMessage = "";
QString applicationName = qApp->applicationFilePath().mid(
qApp->applicationDirPath().length() + 1);
if ((appArguments.length() == 0)
|| (appArguments.contains(QLatin1String("--help")))
|| (appArguments.contains(QLatin1String("-h")))
|| (appArguments.length() == 1
&& (appArguments.at(0) == qApp->applicationFilePath()
|| appArguments.at(0) == (QLatin1String("./") + applicationName)
|| appArguments.at(0) == applicationName)
)) {
displayHelp();
return;
}
if (!parseArguments(appArguments)) {
enterErrorState(QLatin1String("Encountered an error when parsing arguments."));
return;
}
baseClassName = argList->value(ClassName).toString();
outputDir = argList->value(Dir).toString();
wsdl->setWsdlFile(argList->value(Path).toString());
if (wsdl->isErrorState())
enterErrorState(QLatin1String("WSDL error!"));
}
int main(int argc, char **argv)
{
int err;
parseArguments(argc, argv);
if (nodaemon == 0) {
err = daemonise();
if (err != 0) exit(1);
err = writePidFile(pidFile);
if (err != 0) exit(1);
}
err = signalisation();
if (err != 0) exit(1);
serverSocket = openServerSocket(port);
if (serverSocket == -1) exit(1);
request_t req;
response_t resp;
output_t output;
memset(&output, 0, sizeof(output_t));
while (serverSocket != -1) {
memset(&req, 0, sizeof(request_t));
memset(&resp, 0, sizeof(response_t));
int client = serverSocketAccept(serverSocket);
if (client == -1)
continue;
int r = parseRequest(client, &req, &resp);
if (r != 0) {
clientPrintf(client, "HTTP/1.1 %03d\r\n", resp.status);
closeClient(client);
continue;
}
if (1) {
printf("path: %s\n", req.path);
for (int i =0; i < req.num_args; i++)
printf("arg[%d]: %s = %s\n", i, req.names[i], req.values[i]);
}
const char* cmdline = findCommand(req.path);
if (cmdline == NULL) {
log_warn("Daemon: Invalid path: '%s'\n", req.path);
clientPrint(client, "HTTP/1.1 404\r\n");
closeClient(client);
continue;
}
if (execute(&output, cmdline) != 0) {
clientPrint(client, "HTTP/1.1 500\r\n"); // Internal server error
closeClient(client);
continue;
}
if ((output.count > 8) && (strncmp(output.buf, "HTTP/1.1", 8) == 0)) {
clientWrite(client, output.buf, output.count);
} else {
clientPrintf(client, "HTTP/1.1 200\r\nContent-Length: %d\r\n\r\n",
output.count);
clientWrite(client, output.buf, output.count);
}
closeClient(client);
output_clear(&output);
if (req.path) free(req.path);
}
removePidFile(pidFile);
return 0;
}
int main(int argc, char** argv) {
#ifdef _3DS
UNUSED(_mPerfShutdown);
gfxInitDefault();
osSetSpeedupEnable(true);
consoleInit(GFX_BOTTOM, NULL);
if (!allocateRomBuffer()) {
return 1;
}
#elif defined(__SWITCH__)
UNUSED(_mPerfShutdown);
gfxInitDefault();
consoleInit(NULL);
#else
signal(SIGINT, _mPerfShutdown);
#endif
int didFail = 0;
struct mLogger logger = { .log = _log };
mLogSetDefaultLogger(&logger);
struct PerfOpts perfOpts = { false, false, false, 0, 0, 0, false };
struct mSubParser subparser = {
.usage = PERF_USAGE,
.parse = _parsePerfOpts,
.extraOptions = PERF_OPTIONS,
.opts = &perfOpts
};
struct mArguments args = {};
bool parsed = parseArguments(&args, argc, argv, &subparser);
if (!args.fname) {
parsed = false;
}
if (!parsed || args.showHelp) {
usage(argv[0], PERF_USAGE);
didFail = !parsed;
goto cleanup;
}
if (args.showVersion) {
version(argv[0]);
goto cleanup;
}
if (perfOpts.savestate) {
_savestate = VFileOpen(perfOpts.savestate, O_RDONLY);
free(perfOpts.savestate);
}
_outputBuffer = malloc(256 * 256 * 4);
if (perfOpts.csv) {
puts("game_code,frames,duration,renderer");
}
if (perfOpts.server) {
didFail = !_mPerfRunServer(args.fname, &args, &perfOpts);
} else {
didFail = !_mPerfRunCore(args.fname, &args, &perfOpts);
}
free(_outputBuffer);
if (_savestate) {
_savestate->close(_savestate);
}
cleanup:
freeArguments(&args);
#ifdef _3DS
gfxExit();
acExit();
#elif defined(__SWITCH__)
gfxExit();
#endif
return didFail;
}
/* Функция компиляци
* Осуществляется как проверки, так и вызовв других
* функций для проверок или преобразваний.
* Проверки на правельность написания мнемокода ассамблера
* и заменна мнемокода на коды команд, так же замена символов
* адресации на коды адресации, и также меток на их дресса
* - Входные данные: исходные мнемокод ассамблера с виджета
* - Выходные данные: записать данных в ячейки ОЗУ сформированных
* во время выполнения функции
*/
void Compiler::exec(QString &strSource)
{
if(strSource.isEmpty()) return;
QTime startTime = QTime::currentTime();
strSource = parseLabel(strSource);
QStringList slCommandPair = strSource.split(" ");
mBar->setStyleSheet("QProgressBar {border: 1px solid rgb(83, 83, 83);background-color: rgb(38, 40, 41);border-radius: 5px;} QProgressBar::chunk {background-color: rgb(64, 66, 68);width: 20px; }");
mBar->setMaximum(slCommandPair.size() - 1);
mBar->setValue(0);
QStringList debugList;
QString isRegistr, strCode, strCmd, strArg = "000", typeAdrr = "0",
debugArg = " ", debugCmd = " ", resParseCmd = "", error = "";
int indexCmd = 0;
for(int i = 0; i < slCommandPair.size(); i ++, mBar->setValue(i)) {
strCmd = slCommandPair.at(i);
debugCmd = slCommandPair.at(i);
strCmd = strCmd.toLower();
resParseCmd = parseSpecialCommand(strCmd,
i + 1 < slCommandPair.size() ?
slCommandPair.at(i + 1) : " ",
error);
qDebug() <<"ParseCmd: " << resParseCmd;
if(resParseCmd != "-1" && error.isEmpty()) {
mMemory->set(indexCmd, resParseCmd);
debugList.append(strCmd);
indexCmd ++;
} else if(!error.isEmpty()) {
fireError(error, indexCmd); return;
} else {
if(i < slCommandPair.size()) {
if(i + 1 < slCommandPair.size()) {
isRegistr = slCommandPair.at(i + 1);
strCode = isRegistr.contains('r') || isRegistr.contains('R') ?
mGenCode->getCode(strCmd + "R") : mGenCode->getCode(strCmd);
} else {
fireError("нет аргумента для команды: " + strCmd, indexCmd); return;
}
} else {
fireError("нет аргумента для команды: " + strCmd, indexCmd); return;
}
if(strCode != "-1") {
if((i + 1) < slCommandPair.size() ) {
if(mGenCode->getCode(slCommandPair.at(i + 1)) == "-1") {
i ++;
strArg = slCommandPair.at(i); debugArg = strArg;
parseArguments(strArg, typeAdrr);
} else {
fireError("не верный аргумент команды: " + strCmd, indexCmd); return;
}
} else {
fireError("нет аргумента для команды: " + strCmd, indexCmd); return;
}
while(strArg.size() < 3) strArg.push_front("0");
strArg = strArg.replace('r', '0');
debugList.append(debugCmd + " " + debugArg);
mMemory->set(indexCmd, strCode + typeAdrr + strArg);
indexCmd ++;
} else {
if(out) {
fireError(" не верная команда", indexCmd);return;
}
}
}
}
updateLog(startTime);
mDpanel->updateCode(debugList);
}
int main(int argc, char** argv) {
std::cout << std::endl;
char* ref = NULL;
// Important NOT invert (init requires argument to be parsed)
parseArguments(argc,argv);
initSimulator();
size_t N = Options::opts.N;
size_t m = Options::opts.m;
size_t M = Options::opts.M;
size_t Nbar = N - m + 1;
double pe = Options::opts.pe;
std::cout << std::endl;
std::cout << "\t\t+++++ Starting simulation +++++ \n\n";
std::cout << "* Reference generation... ";
ref = new char[N];
generateIIDGenome(N,ref);
std::string s(ref);
std::cout << "[OK]" << std::endl;
std::cout << "* Read generation... ";
std::priority_queue<Read> reads;
generateOfflineReads(s, reads);
std::cout << "[OK]" << std::endl;
std::cout << "* Processing reads... ";
Read r1 = reads.top();
reads.pop();
while(!reads.empty()) {
Read r2 = reads.top();
reads.pop();
size_t s = m - (r2.j - r1.j);
evaluateChainRelation(r1, r2, s);
int dh = -1;
if (s <= m) {
dh = prefixSuffixHammingDistance(r2.r, r1.r, s);
} else {
addNonOverlapRecord(r2.j - r1.j - m);
}
r1 = r2;
}
std::cout << "[OK]" << std::endl;
std::cout << "* Cleaning... ";
delete[] ref;
std::cout << "\n\n";
// printChainMatrix();
//printNonOverlapDistribution();
printFalsePositiveMatrix();
clearSimulator();
std::cout << "[OK]" << std::endl;
std::cout << std::endl;
return 0;
}
int main(int argc, char *argv[])
{
int pid = -1; //PID
float temp = 0; //inital temperature from command line
float downTemp = 0;
float parentTemp = 0;
float upTemp = 0;
//parses command line arguments and updates pid and initial temperature/exits on fail
if(!getArgumentValues(parseArguments(argc, argv), pid, temp)) exit(0);
mqd_t mqueue; /*message queue*/
mqd_t parent;
mqd_t child_1;
mqd_t child_2;
struct mq_attr ma;
ma.mq_flags = 0;
ma.mq_maxmsg = 10;
ma.mq_msgsize = 33;
ma.mq_curmsgs = 0;
float child1Value;
float child2Value;
//sendFloat(mqueue, temp);
//qout << receiveFloat(mqueue);
//mq_close(mqueue);
//mq_unlink(P0);
switch(pid){
case 0:
{
mqueue = openMailbox(P0, ma);
child_1 = openMailbox(P1, ma);
child_2 = openMailbox(P2, ma);
sendFloat(child_1, temp, 0.0); //false flags as sent down
sendFloat(child_2, temp, 0.0);
break;
}
case 1:
parent = openMailbox(P0, ma);
mqueue = openMailbox(P1, ma);
child_1 = openMailbox(P3, ma);
child_2 = openMailbox(P4, ma);
break;
case 2:
parent = openMailbox(P0, ma);
mqueue = openMailbox(P2, ma);
child_1 = openMailbox(P5, ma);
child_2 = openMailbox(P6, ma);
break;
case 3:
parent = openMailbox(P1, ma);
mqueue = openMailbox(P3, ma);
break;
case 4:
parent = openMailbox(P1, ma);
mqueue = openMailbox(P4, ma);
break;
case 5:
parent = openMailbox(P2, ma);
mqueue = openMailbox(P5, ma);
break;
case 6:
parent = openMailbox(P2, ma);
mqueue = openMailbox(P6, ma);
break;
}
bool isStable = false;
while(!isStable)
{
if(pid == 0)
{
if(numMessages(mqueue) > 1)
{
float cPid = 10;
float c2Pid = 10;
float child1Value = receiveFloat(mqueue, cPid);
float child2Value = receiveFloat(mqueue, c2Pid);
upTemp = (temp + child1Value + child2Value)/3.0;
qout << "Process " << pid << " current temperature " << upTemp << endl;
if(qAbs(upTemp - temp) <= .01)
{
temp = upTemp;
isStable = true;
sendFloat(child_1, temp, 20);
sendFloat(child_2, temp, 20);
}
else
{
temp = upTemp;
sendFloat(child_1, temp, pid);
sendFloat(child_2, temp, pid);
}
}
}
if(pid == 1 || pid == 2)
{
if(hasMessages(mqueue))
{
float rPid = 10;
float value = receiveFloat(mqueue, rPid);
if(rPid == 20)
{
isStable = true;
sendFloat(child_1, temp, 20);
sendFloat(child_1, temp, 20);
}
else if(rPid == 0)
{
float downTemp = (temp + value)/2.0;
temp = downTemp;
sendFloat(child_1, downTemp, pid);
sendFloat(child_2, downTemp, pid);
}
else if(rPid == 3 || rPid == 4 || rPid == 5 || rPid == 6)
{
float child1_value = value;
float sPid = 10;
float child2_value = receiveFloat(mqueue, sPid);
if(sPid == 3 || sPid == 4 || sPid == 5 || sPid == 6)
{
upTemp = (temp + child1_value + child2_value)/3.0;
temp = upTemp;
qout << "Process " << pid << " current temperature " << upTemp << endl;
sendFloat(parent, upTemp, pid);
}
}
}
}
if(pid == 3 || pid == 4 || pid == 5 || pid ==6)
{
if(hasMessages(mqueue))
{
float rPid;
parentTemp = receiveFloat(mqueue, rPid);
if(rPid == 20)
{
isStable = true;
}
else
{
downTemp = (temp + parentTemp)/2.0;
temp = downTemp;
sendFloat(parent, downTemp, pid); //true flags it as sent up
qout << "Process " << pid << " current temperature " << downTemp << endl;
}
}
}
}
qout << "Process " << pid << " final temperature " << temp << endl;
mq_close(parent);
mq_close(child_1);
mq_close(child_2);
mq_close(mqueue);
mq_unlink(P0);
mq_unlink(P1);
mq_unlink(P2);
mq_unlink(P3);
mq_unlink(P4);
mq_unlink(P5);
mq_unlink(P6);
return 0;
} /*end main()*/
k_Quantifier::k_Quantifier(QStringList& ak_Arguments, QSet<r_Parameter::Enumeration> ak_Parameters, QString as_ProgramName, QString as_AdditionalArguments)
: k_QuantifierBase(ak_Arguments, ak_Parameters, as_ProgramName, as_AdditionalArguments)
{
parseArguments(ak_Arguments);
}
int main(int argc, char **argv)
{
bool keepGoing = true;
srand(time(NULL)); //seed random generator
parseArguments(argc, argv);
allocWorld();
fillWorld();
Timer renderTimer = makeTimer(1.0 / config.framerate);
if (config.render)
initRender();
if (config.measureSamples < 0) {
/* Loop forever, or until the user quits the renderer */
while (stepSimulation(&renderTimer));
} else {
printf("Waiting for system to relax.\n");
for (double t = 0; keepGoing && t < config.measureWait; t += config.timeStep) {
keepGoing = stepSimulation(&renderTimer);
if (fmod(t, config.measureWait / 100) < config.timeStep) {
printf("\rRelax time %13f of %f",
(t + config.measureWait/100) / TIME_FACTOR,
config.measureWait / TIME_FACTOR);
fflush(stdout);
}
}
/* Perform the measurements */
printf("\nStarting measurement.\n");
FILE *outstream = fopen(DATA_FILE_NAME, "w");
//plotHeader(outstream);
double intervalTime = 0;
for (long sample = 0; keepGoing && sample < config.measureSamples; sample++) {
while (keepGoing && intervalTime <= config.measureInterval) {
keepGoing = stepSimulation(&renderTimer);
intervalTime += config.timeStep;
}
if (!keepGoing)
break;
/* Check for numerical drift (or bugs) before
* commiting measurement. */
if (!physicsCheck())
die("You broke physics!\n");
dumpEnergies(outstream);
printf("\rMeasured sample %ld/%ld", sample + 1, config.measureSamples);
fflush(stdout);
intervalTime -= config.measureInterval;
}
printf("\n");
fclose(outstream);
}
freeWorld();
return 0;
}
ArgumentParser::ArgumentParser(int argc, char * argv[])
: ArgumentCollection() {
parseArguments(argc, argv);
}
PageRunner::PageRunner(const QStringList& args)
: QWebPage(0),
out(stdout),
err(stderr),
view(new QWidget()) {
QMap<QString, QString> settings = parseArguments(args);
QStringList arguments = args.mid(settings.size() * 2);
exportpdf = settings.value("export-pdf");
exportpng = settings.value("export-png");
url = QUrl(arguments[0]);
nativeio = new NativeIO(this, QFileInfo(arguments[0]).dir(),
QDir::current());
if (url.scheme() == "file" || url.isRelative()) {
QFileInfo info(arguments[0]);
url = QUrl::fromLocalFile(info.absoluteFilePath());
if (!info.isReadable() || !info.isFile()) {
QTextStream err(stderr);
err << "Cannot read file '" + url.toString() + "'.\n";
qApp->exit(1);
}
}
nam = new NAM(this, QUrl(url).host(), QUrl(url).port());
setNetworkAccessManager(nam);
connect(this, SIGNAL(loadFinished(bool)), this, SLOT(finished(bool)));
connect(mainFrame(), SIGNAL(javaScriptWindowObjectCleared()),
this, SLOT(slotInitWindowObjects()));
sawJSError = false;
setView(view);
scriptMode = arguments[0].endsWith(".js");
if (scriptMode) {
QByteArray html = "'" + arguments[0].toUtf8().replace('\'', "\\'")
+ "'";
for (int i = 1; i < arguments.length(); ++i) {
html += ",'" + arguments[i].toUtf8().replace('\'', "\\'") + "'";
}
html = "<html>"
"<head><title></title>"
"<script>var arguments=[" + html + "];</script>"
"<script src=\"" + QUrl::fromLocalFile(arguments[0]).toEncoded() + "\"></script>";
// add runtime modification
html += "<script>//<![CDATA[\n" + getRuntimeBindings() +
"if (typeof(runtime) !== 'undefined' && typeof(nativeio) !== 'undefined') {\n"
" runtime.libraryPaths = function () {"
" /* convert to javascript array */"
" var p = nativeio.libraryPaths(),"
" a = [], i;"
" for (i in p) { a[i] = p[i]; }"
" return a;"
" };}//]]></script>";
html += "</head><body></body></html>\n";
QTemporaryFile tmp("XXXXXX.html");
tmp.setAutoRemove(true);
tmp.open();
tmp.write(html);
tmp.close();
QFileInfo info(tmp.fileName());
mainFrame()->load(QUrl::fromLocalFile(info.absoluteFilePath()));
} else {
// Make the url absolute. If it is not done here, QWebFrame will do
// it, and it will lose the query and fragment part.
QUrl absurl;
if (url.isRelative()) {
absurl = QUrl::fromLocalFile(QFileInfo(url.toLocalFile()).absoluteFilePath());
absurl.setQuery(url.query());
absurl.setFragment(url.fragment());
} else {
absurl = url;
}
mainFrame()->load(absurl);
}
}
bool ExprParser::parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner)
{
if (const Extensions *extensions = getContext().getExtensions())
{
std::string argumentType; // ignored
bool hasExplicit = false; // ignored
if (extensions->isInstruction (keyword, argumentType, hasExplicit))
{
// pretend this is not a keyword
return parseName (loc.mLiteral, loc, scanner);
}
}
if (keyword==Scanner::K_end || keyword==Scanner::K_begin ||
keyword==Scanner::K_short || keyword==Scanner::K_long ||
keyword==Scanner::K_float || keyword==Scanner::K_if ||
keyword==Scanner::K_endif || keyword==Scanner::K_else ||
keyword==Scanner::K_elseif || keyword==Scanner::K_while ||
keyword==Scanner::K_endwhile || keyword==Scanner::K_return ||
keyword==Scanner::K_messagebox || keyword==Scanner::K_set ||
keyword==Scanner::K_to || keyword==Scanner::K_startscript ||
keyword==Scanner::K_stopscript || keyword==Scanner::K_enable ||
keyword==Scanner::K_disable)
{
return parseName (loc.mLiteral, loc, scanner);
}
mFirst = false;
if (!mExplicit.empty())
{
if (mRefOp && mNextOperand)
{
if (keyword==Scanner::K_getdisabled)
{
start();
mTokenLoc = loc;
Generator::getDisabled (mCode, mLiterals, mExplicit);
mOperands.push_back ('l');
mExplicit.clear();
mRefOp = false;
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_getdistance)
{
start();
mTokenLoc = loc;
parseArguments ("c", scanner);
Generator::getDistance (mCode, mLiterals, mExplicit);
mOperands.push_back ('f');
mExplicit.clear();
mRefOp = false;
mNextOperand = false;
return true;
}
// check for custom extensions
if (const Extensions *extensions = getContext().getExtensions())
{
char returnType;
std::string argumentType;
bool hasExplicit = true;
if (extensions->isFunction (keyword, returnType, argumentType, hasExplicit))
{
if (!hasExplicit)
{
getErrorHandler().warning ("stray explicit reference (ignoring it)", loc);
mExplicit.clear();
}
start();
mTokenLoc = loc;
int optionals = parseArguments (argumentType, scanner);
extensions->generateFunctionCode (keyword, mCode, mLiterals, mExplicit,
optionals);
mOperands.push_back (returnType);
mExplicit.clear();
mRefOp = false;
mNextOperand = false;
return true;
}
}
}
return Parser::parseKeyword (keyword, loc, scanner);
}
if (mNextOperand)
{
if (keyword==Scanner::K_getsquareroot)
{
start();
mTokenLoc = loc;
parseArguments ("f", scanner);
Generator::squareRoot (mCode);
mOperands.push_back ('f');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_menumode)
{
start();
mTokenLoc = loc;
Generator::menuMode (mCode);
mOperands.push_back ('l');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_random)
{
start();
mTokenLoc = loc;
parseArguments ("l", scanner);
Generator::random (mCode);
mOperands.push_back ('l');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_scriptrunning)
{
start();
mTokenLoc = loc;
parseArguments ("c", scanner);
Generator::scriptRunning (mCode);
mOperands.push_back ('l');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_getdistance)
{
start();
mTokenLoc = loc;
parseArguments ("c", scanner);
Generator::getDistance (mCode, mLiterals, "");
mOperands.push_back ('f');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_getsecondspassed)
{
start();
mTokenLoc = loc;
Generator::getSecondsPassed (mCode);
mOperands.push_back ('f');
mNextOperand = false;
return true;
}
else if (keyword==Scanner::K_getdisabled)
{
start();
mTokenLoc = loc;
Generator::getDisabled (mCode, mLiterals, "");
mOperands.push_back ('l');
mNextOperand = false;
return true;
}
else
{
// check for custom extensions
if (const Extensions *extensions = getContext().getExtensions())
{
start();
char returnType;
std::string argumentType;
bool hasExplicit = false;
if (extensions->isFunction (keyword, returnType, argumentType, hasExplicit))
{
mTokenLoc = loc;
int optionals = parseArguments (argumentType, scanner);
extensions->generateFunctionCode (keyword, mCode, mLiterals, "", optionals);
mOperands.push_back (returnType);
mNextOperand = false;
return true;
}
}
}
}
else
{
// no comma was used between arguments
scanner.putbackKeyword (keyword, loc);
return false;
}
return Parser::parseKeyword (keyword, loc, scanner);
}
/** Constructor. Parses the command-line arguments, resets Rshare's
* configuration (if requested), and sets up the GUI style and language
* translation. */
Rshare::Rshare(QStringList args, int &argc, char **argv, const QString &dir)
: QApplication(argc, argv)
{
mStartupTime = QDateTime::currentDateTime();
#if QT_VERSION >= QT_VERSION_CHECK (5, 0, 0)
qInstallMessageHandler(qt_msg_handler);
#else
qInstallMsgHandler(qt_msg_handler);
#endif
#ifndef __APPLE__
/* set default window icon */
setWindowIcon(QIcon(":/icons/logo_128.png"));
#endif
mBlink = true;
QTimer *timer = new QTimer(this);
timer->setInterval(500);
connect(timer, SIGNAL(timeout()), this, SLOT(blinkTimer()));
timer->start();
timer = new QTimer(this);
timer->setInterval(60000);
connect(timer, SIGNAL(timeout()), this, SIGNAL(minuteTick()));
timer->start();
/* Read in all our command-line arguments. */
parseArguments(args);
/* Check if we're supposed to reset our config before proceeding. */
if (_args.contains(ARG_RESET)) {
Settings->reset();
}
/* Handle the -loglevel and -logfile options. */
if (_args.contains(ARG_LOGFILE))
_log.open(_args.value(ARG_LOGFILE));
if (_args.contains(ARG_LOGLEVEL)) {
_log.setLogLevel(Log::stringToLogLevel(
_args.value(ARG_LOGLEVEL)));
if (!_args.contains(ARG_LOGFILE))
_log.open(stdout);
}
if (!_args.contains(ARG_LOGLEVEL) &&
!_args.contains(ARG_LOGFILE))
_log.setLogLevel(Log::Off);
/* config directory */
useConfigDir = false;
if (dir != "")
{
setConfigDirectory(dir);
}
/** Initialize support for language translations. */
//LanguageSupport::initialize();
resetLanguageAndStyle();
/* Switch off auto shutdown */
setQuitOnLastWindowClosed ( false );
/* Initialize GxsIdDetails */
GxsIdDetails::initialize();
}
int main (int argc, char **argv) {
struct config c = parseArguments(argc, argv);
if (c.error)
return 0;
std::cout << "Starting uEye camera demo..." << std::endl;
//std::cout << "Test message:" << std::endl;
std::cout << "Getting number of cameras" << std::endl;
time_point start = Clock::now();
INT nCam = CameraImpl::getNumberOfCameras();
printTime(start, Clock::now());
std::cout << nCam << " connected camera(s) founded." << std::endl;
std::cout << "Getting the list of available cameras" << std::endl;
start = Clock::now();
UEYE_CAMERA_LIST* cams = CameraImpl::getCameraList(nCam);
printTime(start, Clock::now());
HIDS hCam = 0;
for (INT i = 0; i < cams->dwCount; i++) {
std::cout << "Frame: Camera[" << i << "] ID is " << cams->uci[i].dwCameraID << std::endl;
}
if (cams->dwCount > 0) {
hCam = cams->uci[0].dwCameraID;
}
delete[] cams;
std::cout << std::endl;
CameraImpl cam(hCam); //call the camera implementation
cam.start(false);
if (cam.getCameraState() != CameraImpl::START) {
return 1;
}
std::cout << "Frame: Configuring camera" << std::endl;
start = Clock::now();
cam.config(); //do the configuration of the camera
if (c.pixel != -1) {
cam.setPixelClock(c.pixel); // set the pixel clock
}
if (c.exposure != -1) {
cam.setExposureTime(c.exposure); // set the exposure time
}
if (c.aoi[0] != -1) {
CameraImpl::AreaOfInterest aoi;
for (int i = 0; i < 4; i++) {
aoi[i] = c.aoi[i];
}
cam.setLogicalAOI(aoi); // set the area of interest
}
cam.resume(); // sets Camera state to READY and Software trigger to on
usleep(4000000);
printTime(start, Clock::now());
start = Clock::now();
cam.allocImage(); // Allocate image buffer
printTime(start, Clock::now());
std::cout << std::endl;
//double starttemp = 0; //warmup loop
double finaltemp = 0;
double currenttemp = 0;
int nt = 15;//number of times the temperature must be the same
double reftemp_arr[nt];//Contains the last temperature values
double reftemp = 0;//The stable temperature
//starttemp = cam.getTempCels();
cam.resetImage();
std::cout << "The initial temperature is " << cam.getTempCels() << " Celsius. Heating."<< std::endl;
cam.printPixelClockList();
//cam.setExposureTime(1);
cam.setPixelClock(216);
usleep(4000000);//ns
std::cout << "Setting pixel clock to 216" << std::endl;
//Make a loop heating at least nt times. If the temperature is the same nt times it will be adjusted at that value
for (int aux =0; aux<nt; aux++){//Just the first nt times. Save these values
cam.takeImage();
reftemp_arr [aux] = cam.getTempCels();
std::cout << "The temperature is " << reftemp_arr [aux] << " Celsius. Heating." << std::endl;
}
currenttemp = reftemp_arr[nt-1];
while (currenttemp > reftemp_arr[0]){//warmup loop. If the current temperature is higher than the reference (nt values ago), go heating. If they are equal, stop.
cam.takeImage();
currenttemp = cam.getTempCels();
std::cout << "The temperature is " << currenttemp << " Celsius. Heating." << std::endl;
memmove(reftemp_arr,reftemp_arr+1,sizeof(double)*(nt-1));//Shift to the left
reftemp_arr[nt-1]=currenttemp;//Last measured value
//compare with the previous values, update them as the loops go forward
//if these values are similar (or in a little range?), the stability was reached
//in that case stop the warm-up loop
}
reftemp = currenttemp;
std::cout << "The stable temperature is " << reftemp << " Celsius." << std::endl;
// Back to the "normal" pixel clock
cam.setPixelClock(c.pixel);
std::cout << "Frame: The pixel clock is " << cam.getPixelClock() << " Hz" << std::endl;
cam.setExposureTime(c.exposure);
std::cout << "Frame: The exposure time is " << cam.getExposureTime() << " ms" << std::endl;
for (int j = 0; j < c.blocks; j++) { //open loop over all frame blocks
std::cout << "Exposing block " << j << " of " << c.blocks << std::endl;
//std::cout << "Saving " << c.frames << " images" << std::endl;
std::cout << "The temperature is " << cam.getTempCels() << " Celsius" << std::endl;
start = Clock::now();
std::cout << "The pixel clock is " << cam.getPixelClock() << " Hz" << std::endl;
if (cam.getTempCels() < reftemp){
std::cout << "The current temperature is " << cam.getTempCels() << " Celsius, this is smaller than " << reftemp << " Celsius" << std::endl;
//cam.printPixelClockList();
//cam.setExposureTime(1);
cam.setPixelClock(432);
std::cout << "The pixel clock is " << cam.getPixelClock() << " Hz" << std::endl;
usleep(4000000);//ns
std::cout << "Setting pixel clock to 432" << std::endl;
while (cam.getTempCels() < reftemp){//warmup loop
cam.allocImage(); // Allocate image buffer and sets an image memory active
cam.resetImage();
cam.takeImage();
cam.freeImage();
std::cout << "The temperature is " << cam.getTempCels() << " Celsius" << std::endl;
}
cam.setPixelClock(c.pixel);
std::cout << "The pixel clock is " << cam.getPixelClock() << " Hz" << std::endl;
std::cout << "The exposure time is " << cam.getExposureTime() << " ms" << std::endl;
//cam.setExposureTime(c.exposure);
}
//for (int m = 1; m < 2 ; m++) {// loop for the three colors
// std::cout << "Going for the colors " << m << std::endl;
cam.allocImage(); // Allocate image buffer and sets an image memory active
cam.resetImage(); //clean the memory to take a new image
cam.setPixelClock(c.pixel);
std::cout << "Frame:The pixel clock is " << cam.getPixelClock() << " Hz" << std::endl;
std::cout << "Frame:The exposure time is " << cam.getExposureTime() << " ms" << std::endl;
//cam.setExposureTime(c.exposure);
usleep(4000000);//ns
//if (m == 1) {
//CameraImpl::HardwareGains g = {100, 100, 0, 0}; // change gains to blue
//CameraImpl::HardwareGains g = {100, 0, 0, 0}; // change gains to all three colors
//CameraImpl::HardwareGains g = {100, 22, 0, 22}; // change gains to all three colors
//cam.setHardwareGains(g);
std::ostringstream oss;
//oss << c.filename << j << "blue.jpg";
//oss << c.filename << j << "three_col.jpg";
//oss << c.filename << j << "three_col.png";
//std::cout << "Filename is " << oss.str() << std::endl;
cam.setFileName(oss.str());
//}
// if (m == 2) {
// CameraImpl::HardwareGains g = {100, 0, 100, 0}; // change gains to green
// cam.setHardwareGains(g);
// std::ostringstream oss;
// oss << c.filename << j << "green.jpg";
// std::cout << "Filename is " << oss.str() << std::endl;
// cam.setFileName(oss.str());
// }
// if (m == 3) {
// CameraImpl::HardwareGains g = {100, 0, 0, 100}; // change gains to red
// cam.setHardwareGains(g);
// std::ostringstream oss;
// oss << c.filename << j << "red.jpg";
// std::cout << "Filename is " << oss.str() << std::endl;
// cam.setFileName(oss.str());
// }
// std::cout << "Going for the frames " << std::endl;
for (int i = 0; i < c.frames; i++) { //take c.frames images for averaging
//oss << i;
cam.takeImage();
//cam.saveImage();
cam.addImage();
}
cam.averageImage(c.frames);
//create a string for the filname including the image-block number
//std::ostringstream oss;
oss << c.filename << j << ".fits";
std::cout << "Filename is " << oss.str() << std::endl;
cam.setFileName(oss.str());
//save the image
//cam.saveImages(); //needs a parameter
//cam.saveImage(1); //Save the image in .jpg or .png
cam.saveFitsImage();
//convert the image, if wished
if (c.bmp) {
cam.convertImage(std::string(".bmp"));
}
if (c.jpg) {
cam.convertImage(std::string(".jpg"));
}
if (c.sex) {
cam.runSExtractor();
}
printTime(start, Clock::now());
std::cout << std::endl;
cam.freeImage(); // releases the image memory. Does it also globally unlock the memory?
//} //close the loop for the different colors
std::cout << "Please press enter " << std::endl;
std::cin.ignore();
} //close the loop for the frame blocks
std::cout << "Releasing image buffer" << std::endl;
start = Clock::now();
//cam.freeImage(); // clean the image memory
printTime(start, Clock::now());
start = Clock::now();
cam.pause();
printTime(start, Clock::now());
start = Clock::now();
cam.reset();
printTime(start, Clock::now());
start = Clock::now();
cam.stop();
printTime(start, Clock::now());
return 0;
}
int main(int argc, char* argv[])
{
int status;
int ch;
const char *progname;
char* val = new char[255];
gpioSetup* setup = new gpioSetup;
// reset gpio setup and set defaults
initGpioSetup(setup);
setup->verbose = FASTGPIO_DEFAULT_VERBOSITY;
setup->debug = FASTGPIO_DEFAULT_DEBUG;
// save the program name
progname = argv[0];
//// parse the option arguments
while ((ch = getopt(argc, argv, "vqud")) != -1) {
switch (ch) {
case 'v':
// verbose output
setup->verbose = FASTGPIO_VERBOSITY_ALL;
break;
case 'q':
// quiet output
setup->verbose = FASTGPIO_VERBOSITY_QUIET;
break;
case 'u':
// ubus output
setup->verbose = FASTGPIO_VERBOSITY_JSON;
break;
case 'd':
// debug mode
setup->debug = 1;
break;
default:
usage(progname);
return 0;
}
}
// advance past the option arguments
argc -= optind;
argv += optind;
// parse the arguments
if (parseArguments(progname, argc, argv, setup) == EXIT_FAILURE) {
return EXIT_FAILURE;
}
// check for any pwm processes already running on this pin
status = checkOldProcess(setup);
// run the command
if (setup->cmd != GPIO_CMD_PWM) {
// single gpio command
status = gpioRun(setup);
}
else {
//// continuous gpio commands, need another process
// create the new process
pid_t pid = fork();
if (pid == 0) {
// child process, run the pwm
status = pwmRun(setup);
}
else {
// parent process
if (FASTGPIO_VERBOSE > 0) printf("Launched child pwm process, pid: %d \n", pid);
noteChildPid(setup->pinNumber, pid);
if ( setup->verbose == FASTGPIO_VERBOSITY_JSON ) {
sprintf(val, "%dHz with %d%% duty", setup->pwmFreq, setup->pwmDuty);
printf(FASTGPIO_JSON_STRING, setup->cmdString, setup->pinNumber, val);
}
}
}
// clean-up
delete val;
delete setup;
return 0;
}
int ExprParser::parseArguments (const std::string& arguments, Scanner& scanner)
{
return parseArguments (arguments, scanner, mCode);
}
virtual void run(std::string notParsedArgs) {
std::vector<std::string> parsedArgs = parseArguments(notParsedArgs);
if (checkNumberOfArguments(parsedArgs.size(), 1, out)) {
manager.run(atoi(parsedArgs[0].c_str()));
}
}
int main(int argc, char *argv[])
{
float *h_psum; // vector to hold partial sum
int in_nsteps = INSTEPS; // default number of steps (updated later to device prefereable)
int niters = ITERS; // number of iterations
int nsteps;
float step_size;
::size_t nwork_groups;
::size_t max_size, work_group_size = 8;
float pi_res;
cl::Buffer d_partial_sums;
try
{
cl_uint deviceIndex = 0;
parseArguments(argc, argv, &deviceIndex);
// Get list of devices
std::vector<cl::Device> devices;
unsigned numDevices = getDeviceList(devices);
// Check device index in range
if (deviceIndex >= numDevices)
{
std::cout << "Invalid device index (try '--list')\n";
return EXIT_FAILURE;
}
cl::Device device = devices[deviceIndex];
std::string name;
getDeviceName(device, name);
std::cout << "\nUsing OpenCL device: " << name << "\n";
std::vector<cl::Device> chosen_device;
chosen_device.push_back(device);
cl::Context context(chosen_device);
cl::CommandQueue queue(context, device);
// Create the program object
cl::Program program(context, util::loadProgram("../pi_ocl.cl"), true);
// Create the kernel object for quering information
cl::Kernel ko_pi(program, "pi");
// Get the work group size
work_group_size = ko_pi.getWorkGroupInfo<CL_KERNEL_WORK_GROUP_SIZE>(device);
//printf("wgroup_size = %lu\n", work_group_size);
cl::make_kernel<int, float, cl::LocalSpaceArg, cl::Buffer> pi(program, "pi");
// Now that we know the size of the work_groups, we can set the number of work
// groups, the actual number of steps, and the step size
nwork_groups = in_nsteps/(work_group_size*niters);
if ( nwork_groups < 1) {
nwork_groups = device.getInfo<CL_DEVICE_MAX_COMPUTE_UNITS>();
work_group_size=in_nsteps / (nwork_groups*niters);
}
nsteps = work_group_size * niters * nwork_groups;
step_size = 1.0f/static_cast<float>(nsteps);
std::vector<float> h_psum(nwork_groups);
printf(
" %d work groups of size %d. %d Integration steps\n",
(int)nwork_groups,
(int)work_group_size,
nsteps);
d_partial_sums = cl::Buffer(context, CL_MEM_WRITE_ONLY, sizeof(float) * nwork_groups);
util::Timer timer;
// Execute the kernel over the entire range of our 1d input data set
// using the maximum number of work group items for this device
pi(
cl::EnqueueArgs(
queue,
cl::NDRange(nsteps / niters),
cl::NDRange(work_group_size)),
niters,
step_size,
cl::Local(sizeof(float) * work_group_size),
d_partial_sums);
cl::copy(queue, d_partial_sums, h_psum.begin(), h_psum.end());
// complete the sum and compute final integral value
pi_res = 0.0f;
for (unsigned int i = 0; i< nwork_groups; i++) {
pi_res += h_psum[i];
}
pi_res = pi_res * step_size;
//rtime = wtime() - rtime;
double rtime = static_cast<double>(timer.getTimeMilliseconds()) / 1000.;
printf("\nThe calculation ran in %lf seconds\n", rtime);
printf(" pi = %f for %d steps\n", pi_res, nsteps);
}
catch (cl::Error err) {
std::cout << "Exception\n";
std::cerr
<< "ERROR: "
<< err.what()
<< "("
<< err_code(err.err())
<< ")"
<< std::endl;
}
}
void rrd_graph_script(
int argc,
char *argv[],
image_desc_t *const im,
int optno)
{
int i;
/* and now handle the things*/
parsedargs_t pa;
initParsedArguments(&pa);
/* loop arguments */
for (i = optno; i < argc; i++) {
/* release parsed args - avoiding late cleanups*/
freeParsedArguments(&pa);
/* processed parsed args */
if (parseArguments(argv[i],&pa)) {
return; }
/* dumpArguments(&pa); */
/* now let us handle the field based on the first command or cmd=...*/
char*cmd=NULL;
/* and try to get via cmd */
char* t=getKeyValueArgument("cmd",255,&pa);
if (t) {
cmd=t;
} else if ((t=getKeyValueArgument("pos0",255,&pa))) {
cmd=t;
} else {
rrd_set_error("no command set in argument %s",pa.arg_orig);
freeParsedArguments(&pa);
return;
}
/* convert to enum but handling LINE special*/
enum gf_en gf = (enum gf_en) -1;
gf=gf_conv(cmd);
if ((int)gf == -1) {
if (strncmp("LINE",cmd,4)==0) {
gf=GF_LINE;
addToArguments(&pa,NULL,"linewidth",cmd+4,0);
} else {
rrd_set_error("'%s' is not a valid function name in %s", cmd,pa.arg_orig );
return;
}
}
/* now we can handle the commands */
int r=0;
switch (gf) {
case GF_XAXIS: r=parse_axis(gf,&pa,im); break;
case GF_YAXIS: r=parse_axis(gf,&pa,im); break;
case GF_DEF: r=parse_def(gf,&pa,im); break;
case GF_CDEF: r=parse_cvdef(gf,&pa,im); break;
case GF_VDEF: r=parse_cvdef(gf,&pa,im); break;
case GF_LINE: r=parse_line(gf,&pa,im); break;
case GF_AREA: r=parse_area(gf,&pa,im); break;
case GF_PRINT: r=parse_gprint(gf,&pa,im); break;
case GF_GPRINT: r=parse_gprint(gf,&pa,im); break;
case GF_COMMENT: r=parse_comment(gf,&pa,im); break;
case GF_HRULE: r=parse_hvrule(gf,&pa,im); break;
case GF_VRULE: r=parse_hvrule(gf,&pa,im); break;
case GF_STACK: r=parse_stack(gf,&pa,im); break;
case GF_TICK: r=parse_tick(gf,&pa,im); break;
case GF_TEXTALIGN: r=parse_textalign(gf,&pa,im); break;
case GF_SHIFT: r=parse_shift(gf,&pa,im); break;
case GF_XPORT: r=parse_xport(gf,&pa,im); break;
/* unsupported types right now */
}
/* handle the return error case */
if (r) { freeParsedArguments(&pa); return;}
/* check for unprocessed keyvalue args */
char *s;
if ((s=checkUnusedValues(&pa))) {
/* set error message */
rrd_set_error("Unused Arguments \"%s\" in command : %s",s,pa.arg_orig);
free(s);
/* exit early */
freeParsedArguments(&pa);
return;
}
}
/* finally free arguments */
freeParsedArguments(&pa);
}
UDTTest::UDTTest(int& argc, char** argv) :
QCoreApplication(argc, argv)
{
qInstallMessageHandler(LogHandler::verboseMessageHandler);
parseArguments();
// randomize the seed for packet size randomization
srand(time(NULL));
_socket.bind(QHostAddress::AnyIPv4, _argumentParser.value(PORT_OPTION).toUInt());
qDebug() << "Test socket is listening on" << _socket.localPort();
if (_argumentParser.isSet(TARGET_OPTION)) {
// parse the IP and port combination for this target
QString hostnamePortString = _argumentParser.value(TARGET_OPTION);
QHostAddress address { hostnamePortString.left(hostnamePortString.indexOf(':')) };
quint16 port { (quint16) hostnamePortString.mid(hostnamePortString.indexOf(':') + 1).toUInt() };
if (address.isNull() || port == 0) {
qCritical() << "Could not parse an IP address and port combination from" << hostnamePortString << "-" <<
"The parsed IP was" << address.toString() << "and the parsed port was" << port;
QMetaObject::invokeMethod(this, "quit", Qt::QueuedConnection);
} else {
_target = HifiSockAddr(address, port);
qDebug() << "Packets will be sent to" << _target;
}
}
if (_argumentParser.isSet(PACKET_SIZE)) {
// parse the desired packet size
_minPacketSize = _maxPacketSize = _argumentParser.value(PACKET_SIZE).toInt();
if (_argumentParser.isSet(MIN_PACKET_SIZE) || _argumentParser.isSet(MAX_PACKET_SIZE)) {
qCritical() << "Cannot set a min packet size or max packet size AND a specific packet size.";
QMetaObject::invokeMethod(this, "quit", Qt::QueuedConnection);
}
} else {
bool customMinSize = false;
if (_argumentParser.isSet(MIN_PACKET_SIZE)) {
_minPacketSize = _argumentParser.value(MIN_PACKET_SIZE).toInt();
customMinSize = true;
}
if (_argumentParser.isSet(MAX_PACKET_SIZE)) {
_maxPacketSize = _argumentParser.value(MAX_PACKET_SIZE).toInt();
// if we don't have a min packet size we should make it 1, because we have a max
if (customMinSize) {
_minPacketSize = 1;
}
}
if (_maxPacketSize < _minPacketSize) {
qCritical() << "Cannot set a max packet size that is smaller than the min packet size.";
QMetaObject::invokeMethod(this, "quit", Qt::QueuedConnection);
}
}
if (_argumentParser.isSet(MAX_SEND_BYTES)) {
_maxSendBytes = _argumentParser.value(MAX_SEND_BYTES).toInt();
}
if (_argumentParser.isSet(MAX_SEND_PACKETS)) {
_maxSendPackets = _argumentParser.value(MAX_SEND_PACKETS).toInt();
}
if (_argumentParser.isSet(UNRELIABLE_PACKETS)) {
_sendReliable = false;
}
if (_argumentParser.isSet(ORDERED_PACKETS)) {
_sendOrdered = true;
}
if (_argumentParser.isSet(MESSAGE_SIZE)) {
if (_argumentParser.isSet(ORDERED_PACKETS)) {
static const double BYTES_PER_MEGABYTE = 1000000;
_messageSize = (int) _argumentParser.value(MESSAGE_SIZE).toInt() * BYTES_PER_MEGABYTE;
qDebug() << "Message size for ordered packet sending is" << QString("%1MB").arg(_messageSize / BYTES_PER_MEGABYTE);
} else {
qWarning() << "message-size has no effect if not sending ordered - it will be ignored";
}
}
// in case we're an ordered sender or receiver setup our random number generator now
static const int FIRST_MESSAGE_SEED = 742272;
int messageSeed = FIRST_MESSAGE_SEED;
if (_argumentParser.isSet(MESSAGE_SEED)) {
messageSeed = _argumentParser.value(MESSAGE_SEED).toInt();
}
// seed the generator with a value that the receiver will also use when verifying the ordered message
_generator.seed(messageSeed);
if (!_target.isNull()) {
sendInitialPackets();
} else {
// this is a receiver - in case there are ordered packets (messages) being sent to us make sure that we handle them
// so that they can be verified
_socket.setMessageHandler(
[this](std::unique_ptr<udt::Packet> packet) {
auto messageNumber = packet->getMessageNumber();
auto it = _pendingMessages.find(messageNumber);
if (it == _pendingMessages.end()) {
auto message = std::unique_ptr<Message>(new Message { messageNumber, packet->readAll() });
message->data.reserve(_messageSize);
if (packet->getPacketPosition() == udt::Packet::ONLY) {
handleMessage(std::move(message));
} else {
_pendingMessages[messageNumber] = std::move(message);
}
} else {
auto& message = it->second;
message->data.append(packet->readAll());
if (packet->getPacketPosition() == udt::Packet::LAST) {
handleMessage(std::move(message));
_pendingMessages.erase(it);
}
}
});
}
_socket.setMessageFailureHandler(
[this](HifiSockAddr from, udt::Packet::MessageNumber messageNumber) {
_pendingMessages.erase(messageNumber);
}
);
// the sender reports stats every 100 milliseconds, unless passed a custom value
if (_argumentParser.isSet(STATS_INTERVAL)) {
_statsInterval = _argumentParser.value(STATS_INTERVAL).toInt();
}
QTimer* statsTimer = new QTimer(this);
connect(statsTimer, &QTimer::timeout, this, &UDTTest::sampleStats);
statsTimer->start(_statsInterval);
}
int main (int argc, char **argv) {
struct config c = parseArguments(argc, argv);
if (c.error)
return 0;
std::cout << "Starting uEye camera demo..." << std::endl;
//std::cout << "Test message:" << std::endl;
std::cout << "Getting number of cameras" << std::endl;
time_point start = Clock::now();
INT nCam = CameraImpl::getNumberOfCameras();
printTime(start, Clock::now());
std::cout << "We found " << nCam << " connected camera(s)." << std::endl;
std::cout << "Getting the list of available cameras" << std::endl;
start = Clock::now();
UEYE_CAMERA_LIST* cams = CameraImpl::getCameraList(nCam);
printTime(start, Clock::now());
HIDS hCam = 0;
for (INT i = 0; i < cams->dwCount; i++) {
std::cout << "Camera[" << i << "] ID is " << cams->uci[i].dwCameraID << std::endl;
}
if (cams->dwCount > 0) {
hCam = cams->uci[0].dwCameraID;
}
delete[] cams;
std::cout << std::endl;
CameraImpl cam(hCam); //call the camera implementation
cam.start(false);
if (cam.getCameraState() != CameraImpl::START) {
return 1;
}
std::cout << "Configuring camera" << std::endl;
start = Clock::now();
cam.config(); //do the configuration of the camera
if (c.pixel != -1) {
cam.setPixelClock(c.pixel); // set the pixel clock
}
if (c.exposure != -1) {
cam.setExposureTime(c.exposure); // set the exposure time
}
if (c.aoi[0] != -1) {
CameraImpl::AreaOfInterest aoi;
for (int i = 0; i < 4; i++) {
aoi[i] = c.aoi[i];
}
cam.setLogicalAOI(aoi); // set the area of interest
}
cam.resume(); // sets Camera state to READY and Software trigger to on
usleep(4000000);
printTime(start, Clock::now());
std::cout << "Allocating image buffer" << std::endl;
start = Clock::now();
cam.allocImage(); // Allocate image buffer
printTime(start, Clock::now());
std::cout << std::endl;
double starttemp=0; //warmup loop
double finaltemp=0;
starttemp = cam.getTempCels();
std::cout << "startemp is " << starttemp << std::endl;
//finaltemp = starttemp + c.degrees;
finaltemp = c.degrees;// set the absolute temperature
std::cout << "finaltemp is " << finaltemp << c.degrees << std::endl;
cam.resetImage();
if (cam.getTempCels() < finaltemp){
std::cout << "The actual temperature is " << cam.getTempCels() << " Celsius" << " this is smaller than " << finaltemp << std::endl;
cam.printPixelClockList();
//cam.setExposureTime(1);
cam.setPixelClock(216);
usleep(4000000);//ns
std::cout << "Setting pixel clock to 216" << std::endl;
while (cam.getTempCels() < finaltemp){//warmup loop
cam.takeImage();
std::cout << "The temperature is " << cam.getTempCels() << " Celsius" << std::endl;
}
cam.setPixelClock(c.pixel);
std::cout << "The pixel clock is " << cam.getPixelClock() << " Hz?" << std::endl;
cam.setExposureTime(c.exposure);
std::cout << "The exposure time is " << cam.getExposureTime() << " ms" << std::endl;
}
for (int j = 0; j < c.blocks; j++) { //open loop over all frame blocks
std::cout << "Exposing block " << j << " of " << c.blocks << std::endl;
std::cout << "Saving " << c.frames << " images" << std::endl;
std::cout << "The temperature is " << cam.getTempCels() << " Celsius" << std::endl;
start = Clock::now();
std::cout << "The pixel clock is " << cam.getPixelClock() << " Hz?" << std::endl;
if (cam.getTempCels() < finaltemp){
std::cout << "The actual temperature is " << cam.getTempCels() << " Celsius" << " this is smaller than " << finaltemp << std::endl;
//cam.printPixelClockList();
//cam.setExposureTime(1);
cam.setPixelClock(432);
std::cout << "The pixel clock is " << cam.getPixelClock() << " Hz?" << std::endl;
usleep(4000000);//ns
std::cout << "Setting pixel clock to 432" << std::endl;
while (cam.getTempCels() < finaltemp){//warmup loop
cam.allocImage(); // Allocate image buffer and sets an image memory active
cam.resetImage();
cam.takeImage();
cam.freeImage();
std::cout << "The temperature is " << cam.getTempCels() << " Celsius" << std::endl;
}
cam.setPixelClock(c.pixel);
std::cout << "The pixel clock is " << cam.getPixelClock() << " Hz?" << std::endl;
std::cout << "The exposure time is " << cam.getExposureTime() << " ms" << std::endl;
//cam.setExposureTime(c.exposure);
}
cam.allocImage(); // Allocate image buffer and sets an image memory active
cam.resetImage(); //clean the memory to take a new image
cam.setPixelClock(c.pixel);
std::cout << "The pixel clock is " << cam.getPixelClock() << " Hz?" << std::endl;
std::cout << "The exposure time is " << cam.getExposureTime() << " ms" << std::endl;
//cam.setExposureTime(c.exposure);
usleep(4000000);//ns
for (int i = 0; i < c.frames; i++) {
cam.takeImage();
//cam.saveImage();
cam.addImage();
}
cam.averageImage(c.frames);
//create a string for the filname including the image-block number
std::ostringstream oss;
oss << c.filename << j << ".fit";
std::cout << "Filename is " << oss.str() << std::endl;
cam.setFileName(oss.str());
//save the image
cam.saveFitsImage();
//convert the image, if wished
if (c.bmp) {
cam.convertImage(std::string(".bmp"));
}
if (c.jpg) {
cam.convertImage(std::string(".jpg"));
}
if (c.sex) {
cam.runSExtractor();
}
printTime(start, Clock::now());
std::cout << std::endl;
cam.freeImage(); // releases the image memory. Does it also globally unlock the memory?
std::cout << "Please press enter " << std::endl;
std::cin.ignore();
//restart the camera after 100 images...
//if (j == 100) {
// //cam.resetImage()
// std::cout << "Image 100. Cleaning memory" << std::endl;
// cam.freeImage(); // clean the image memory
// //cam.allocImage(); // Allocate image buffer
// cam.pause();
// //cam.reset();
// //std::cout << "Image 100. Camera reset memory" << std::endl;
// //cam.resume();
// cam.reset();
// cam.stop();
// cam.start(false);
// if (cam.getCameraState() != CameraImpl::START) {
// return 1;
// }
// cam.config();
// cam.resume();
// usleep(4000000);
// cam.allocImage(); // Allocate image buffer
// cam.resetImage();
//}
} //close the loop for the frame blocks
std::cout << "Releasing image buffer" << std::endl;
start = Clock::now();
cam.freeImage(); // clean the image memory
printTime(start, Clock::now());
start = Clock::now();
cam.pause();
printTime(start, Clock::now());
start = Clock::now();
cam.reset();
printTime(start, Clock::now());
start = Clock::now();
cam.stop();
printTime(start, Clock::now());
return 0;
}
