void register_ethernet()
{
eth_event_group = xEventGroupCreate();
tcpip_adapter_init();
ESP_ERROR_CHECK(esp_event_loop_init(eth_event_handler, NULL));
eth_config_t config = DEFAULT_ETHERNET_PHY_CONFIG;
config.phy_addr = CONFIG_PHY_ADDRESS;
config.gpio_config = eth_gpio_config_rmii;
config.tcpip_input = tcpip_adapter_eth_input;
config.clock_mode = CONFIG_PHY_CLOCK_MODE;
#ifdef CONFIG_PHY_USE_POWER_PIN
/* Replace the default 'power enable' function with an example-specific one
that toggles a power GPIO. */
config.phy_power_enable = phy_device_power_enable_via_gpio;
#endif
ESP_ERROR_CHECK(esp_eth_init(&config));
eth_control_args.control = arg_str1(NULL, NULL, "<start|stop|info>", "Start/Stop Ethernet or Get info of Ethernet");
eth_control_args.end = arg_end(1);
const esp_console_cmd_t cmd = {
.command = "ethernet",
.help = "Control Ethernet interface",
.hint = NULL,
.func = eth_cmd_control,
.argtable = ð_control_args
};
ESP_ERROR_CHECK(esp_console_cmd_register(&cmd));
iperf_args.ip = arg_str0("c", "client", "<ip>",
"run in client mode, connecting to <host>");
iperf_args.server = arg_lit0("s", "server", "run in server mode");
iperf_args.udp = arg_lit0("u", "udp", "use UDP rather than TCP");
iperf_args.port = arg_int0("p", "port", "<port>",
"server port to listen on/connect to");
iperf_args.interval = arg_int0("i", "interval", "<interval>",
"seconds between periodic bandwidth reports");
iperf_args.time = arg_int0("t", "time", "<time>", "time in seconds to transmit for (default 10 secs)");
iperf_args.abort = arg_lit0("a", "abort", "abort running iperf");
iperf_args.end = arg_end(1);
const esp_console_cmd_t iperf_cmd = {
.command = "iperf",
.help = "iperf command",
.hint = NULL,
.func = ð_cmd_iperf,
.argtable = &iperf_args
};
ESP_ERROR_CHECK(esp_console_cmd_register(&iperf_cmd));
}
bool Application::initArgtable()
{
const char* progname = "revisor";
struct arg_str* l = arg_str0("l", NULL, "<interface>", "Interface to listen, default '127.0.0.1'");
struct arg_int* p = arg_int0("p", NULL, "<port number>", "Port to listen, default 8080");
struct arg_lit* h = arg_lit0("h", "help", "This help message");
struct arg_end* end = arg_end(20);
void *argtable[] = {l, p, h, end};
int nerrors = arg_parse(argc, argv, argtable);
// special case: '--help' takes precedence over error reporting
if (h->count > 0) {
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
arg_print_glossary(stdout, argtable, " %-25s %s\n");
return false;
}
if (nerrors > 0) {
arg_print_errors(stdout, end, progname);
return false;
}
if (l->count > 0) {
listeningInterface = l->sval[0];
}
if (p->count > 0) {
portNumber = *p->ival;
}
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
return true;
}
int main(int argc, char *argv[]) {
// First: Sort out the command line.
struct arg_file *files_to_verify = arg_filen(NULL, NULL, "<table file>", 0, 100000, "GRT parts to verify.");
struct arg_dbl *percent = arg_dbl0(NULL, "percent", "[0-100]", "Percent of chains to randomly verify.");
struct arg_int *sequential = arg_int0(NULL, "sequential", "<n>", "Check every nth chain");
/*
void *argtable[] = {table_files, output_directory, bits, move_source, end};
// Get arguments, collect data, check for basic errors.
if (arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
}
// Look for errors
int nerrors = arg_parse(argc,argv,argtable);
if (nerrors > 0) {
// Print errors, exit.
arg_print_errors(stdout,end,argv[0]);
// Print help.
printf("\n\nOptions: \n");
arg_print_glossary(stdout,argtable," %-20s %s\n");
exit(1);
}
*/
}
/*
* All code below is "unimportant", it's only argument and file handling
*/
int main(int argc, char *argv[]) {
struct arg_file *ifile = arg_file1("i", "input-file", "INPUT_FILE", "Set Input File");
struct arg_file *ofile = arg_file0("o", "output-file", "OUTPUT_FILE", "Set Output File");
struct arg_str *pass = arg_str0("p", "password", "PASSWORD", "Set Encryption Password");
struct arg_int *pas = arg_int0("c", "passes", "PASSES", "Set number of passes (To decrypt you'll need the same number of passes)");
struct arg_int *buf = arg_int0("b", "buffer-size", "BUFFER_SIZE", "Set Buffer Size");
struct arg_end *end = arg_end(20);
void *argtable[] = {
ifile, ofile, pass, pas, buf, end};
int nerrors = arg_parse(argc, argv, argtable);
if (nerrors > 0) {
arg_print_errors(stdout, end, "rxe");
printf("\nUsage: rxe");
arg_print_syntax(stdout, argtable, "\n");
arg_print_glossary(stdout, argtable, " %-10s %s\n");
} else {
if (buf->count > 0) {
BUFFER_SIZE = buf->ival[0];
}
FILE *outfile, *infile = fopen(ifile->filename[0], "rb");
if (ofile->count > 0) outfile = fopen(ofile->filename[0], "wb");
else {
char farr[2048];
char *ptr;
strcpy(farr, ifile->filename[0]);
if ((ptr = strstr(farr, ".rxe")) != NULL) {
farr[0] = '\0';
farr[1] = '\0';
farr[2] = '\0';
farr[3] = '\0';
} else strcat(farr, ".rxe");
outfile = fopen(farr, "wb");
}
if(pas->count > 0) PASSES = pas->ival[0];
if(pass->count > 0) RXE_Main(infile, outfile, (char *)pass->sval[0]);
else RXE_Main(infile, outfile, "DEFAULT");
fclose(outfile);
fclose(infile);
}
return 0;
}
void parse_command_line(int argc, char* argv[])
{
// if the parsing of the arguments was unsuccessful
int nerrors;
// Define argument table structs
python_folder = arg_file0 ( NULL, "py-folder", "<path to file>", "Path to folder (relative or absolute) that contains python script (default: lpfw-pygui)" );
log_debug = arg_int0 ( NULL, "log-debug", "<1/0 for yes/no>", "Enable debug messages logging" );
struct arg_lit *help = arg_lit0 ( NULL, "help", "Display this help screen" );
struct arg_lit *version = arg_lit0 ( NULL, "version", "Display the current version" );
struct arg_end *end = arg_end ( 10 );
void *argtable[] = {python_folder, log_debug, help, version, end};
// Set default values
char *python_folder_pointer = malloc(strlen("lpfw-pygui")+1);
strcpy (python_folder_pointer, "lpfw-pygui");
python_folder->filename[0] = python_folder_pointer;
* ( log_debug->ival ) = 0;
if ( arg_nullcheck ( argtable ) != 0 )
{
printf ( "Error: insufficient memory\n" );
exit(0);
}
nerrors = arg_parse ( argc, argv, argtable );
if ( nerrors == 0 )
{
if ( help->count == 1 )
{
printf ( "Leopard Flower frontend :\n Syntax and help:\n" );
arg_print_glossary ( stdout, argtable, "%-43s %s\n" );
exit (0);
}
else if ( version->count == 1 )
{
printf ( "%s\n", VERSION );
exit (0);
}
}
else if ( nerrors > 0 )
{
arg_print_errors ( stdout, end, "Leopard Flower frontend" );
printf ( "Leopard Flower frontend:\n Syntax and help:\n" );
arg_print_glossary ( stdout, argtable, "%-43s %s\n" );
exit (1);
}
// Free memory - don't do this cause args needed later on
// arg_freetable(argtable, sizeof (argtable) / sizeof (argtable[0]));
}
int main(int argc, char *argv[])
{
/* the global arg_xxx structs are initialised within the argtable */
void *argtable[] = {
help = arg_lit0(NULL, "help", "display this help and exit"),
version = arg_lit0(NULL, "version", "display version info and exit"),
a = arg_lit0("a", NULL,"the -a option"),
b = arg_lit0("b", NULL, "the -b option"),
c = arg_lit0("c", NULL, "the -c option"),
scal = arg_int0(NULL, "scalar", "<n>", "foo value"),
verb = arg_lit0("v", "verbose", "verbose output"),
o = arg_file0("o", NULL, "myfile", "output file"),
file = arg_filen(NULL, NULL, "<file>", 0, 100, "input files"),
end = arg_end(20),
};
int exitcode = 0;
char progname[] = "testargtable3.exe";
int nerrors;
nerrors = arg_parse(argc,argv,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
printf("List information about the FILE(s) "
"(the current directory by default).\n\n");
arg_print_glossary(stdout, argtable, " %-25s %s\n");
exitcode = 0;
goto exit;
}
/* If the parser returned any errors then display them and exit */
if (nerrors > 0)
{
/* Display the error details contained in the arg_end struct.*/
arg_print_errors(stdout, end, progname);
printf("Try '%s --help' for more information.\n", progname);
exitcode = 1;
goto exit;
}
exit:
/* deallocate each non-null entry in argtable[] */
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
return exitcode;
}
int _tmain(int argc, char* argv[])
{
// determine my process name
_splitpath(argv[0],NULL,NULL,gszProcName,NULL);
#else
int
main(int argc, const char** argv)
{
// determine my process name
CUtility::splitpath((char *)argv[0],NULL,gszProcName);
#endif
int iScreenLogLevel; // level of screen diagnostics
int iFileLogLevel; // level of file diagnostics
char szLogFile[_MAX_PATH]; // write diagnostics to this file
int Rslt;
int Idx;
int iMode = 0; // processing mode
int iRandSeed = 0; // random base seed to use (if < 0 then current time used to seed generator)
int KMerLen; // what length kmer to generate for 1..cMaxKMerLen
int NumInFileSpecs; // number of input file specs
char *pszInFiles[cMaxInFileSpecs]; // input control aligned reads files
char szOutputFile[_MAX_PATH];
// command line args
struct arg_lit *help = arg_lit0("hH","help", "print this help and exit");
struct arg_lit *version = arg_lit0("v","version,ver", "print version information and exit");
struct arg_int *FileLogLevel=arg_int0("f", "FileLogLevel", "<int>","Level of diagnostics written to screen and logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug");
struct arg_file *LogFile = arg_file0("F","log","<file>", "diagnostics log file");
struct arg_int *Mode = arg_int0("m","mode","<int>", "processing mode - 0 randomise genome");
struct arg_int *kmerlen = arg_int0("k","kmerlen","<int>", "maintain frequency composition of K-mer length (default = 1, range 1..15)");
struct arg_file *InFiles = arg_filen("i",NULL,"<file>",1,cMaxInFileSpecs, "input genome assembly multifasta files (s) to randomise");
struct arg_file *OutFile= arg_file1("o",NULL,"<file>", "output randomised assembly to this file as multifasta");
struct arg_int *RandSeed = arg_int0("s","randseed","<int>", "random seed to use (default is use system time)");
struct arg_end *end = arg_end(20);
void *argtable[] = {help,version,FileLogLevel,LogFile,Mode,kmerlen,InFiles,OutFile,RandSeed,end};
char **pAllArgs;
int argerrors;
argerrors = CUtility::arg_parsefromfile(argc,(char **)argv,&pAllArgs);
if(argerrors >= 0)
argerrors = arg_parse(argerrors,pAllArgs,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("\n%s Kanga randomise genome K-mers, Version %s\nOptions ---\n", gszProcName,cpszProgVer);
arg_print_syntax(stdout,argtable,"\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
printf("\nNote: Parameters can be entered into a parameter file, one parameter per line.");
printf("\n To invoke this parameter file then precede its name with '@'");
printf("\n e.g. %s @myparams.txt\n",gszProcName);
printf("\nPlease report any issues regarding usage of %s at https://github.com/csiro-crop-informatics/biokanga/issues\n\n",gszProcName);
exit(1);
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0)
{
printf("\n%s Version %s\n",gszProcName,cpszProgVer);
exit(1);
}
if (!argerrors)
{
if(FileLogLevel->count && !LogFile->count)
{
printf("\nError: FileLogLevel '-f%d' specified but no logfile '-F<logfile>\n'",FileLogLevel->ival[0]);
exit(1);
}
iScreenLogLevel = iFileLogLevel = FileLogLevel->count ? FileLogLevel->ival[0] : eDLInfo;
if(iFileLogLevel < eDLNone || iFileLogLevel > eDLDebug)
{
printf("\nError: FileLogLevel '-l%d' specified outside of range %d..%d\n",iFileLogLevel,eDLNone,eDLDebug);
exit(1);
}
if(LogFile->count)
{
strncpy(szLogFile,LogFile->filename[0],_MAX_PATH);
szLogFile[_MAX_PATH-1] = '\0';
}
else
{
iFileLogLevel = eDLNone;
szLogFile[0] = '\0';
}
// now that log parameters have been parsed then initialise diagnostics log system
if(!gDiagnostics.Open(szLogFile,(etDiagLevel)iScreenLogLevel,(etDiagLevel)iFileLogLevel,true))
{
printf("\nError: Unable to start diagnostics subsystem\n");
if(szLogFile[0] != '\0')
printf(" Most likely cause is that logfile '%s' can't be opened/created\n",szLogFile);
exit(1);
}
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Version: %s",cpszProgVer);
iMode = Mode->count ? Mode->ival[0] : 0;
if(iMode < 0 || iMode >= cMaxSupportedModes)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Unsupported Mode '-m%d' requested",iMode);
exit(1);
}
KMerLen = 0;
switch(iMode) {
case 0: // generate random species fasta sequence
for(NumInFileSpecs=Idx=0;NumInFileSpecs < cMaxInFileSpecs && Idx < InFiles->count; Idx++)
{
pszInFiles[Idx] = NULL;
if(pszInFiles[NumInFileSpecs] == NULL)
pszInFiles[NumInFileSpecs] = new char [_MAX_PATH];
strncpy(pszInFiles[NumInFileSpecs],InFiles->filename[Idx],_MAX_PATH);
pszInFiles[NumInFileSpecs][_MAX_PATH-1] = '\0';
CUtility::TrimQuotedWhitespcExtd(pszInFiles[NumInFileSpecs]);
if(pszInFiles[NumInFileSpecs][0] != '\0')
NumInFileSpecs++;
}
if(!NumInFileSpecs)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no input file(s) specified with '-i<filespec>' option)\n");
exit(1);
}
KMerLen = kmerlen->count ? kmerlen->ival[0] : cDfltKMerLen;
if(KMerLen < 1 || KMerLen > cMaxKMerLen)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: K-mer length specified with '-k%d' is outside of range 1..10",KMerLen);
exit(1);
}
if(!OutFile->count || OutFile->filename[0][0] == '\0')
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: No output fasta file specified with '-o<filename>'");
exit(1);
}
strncpy(szOutputFile,OutFile->filename[0],_MAX_PATH);
szOutputFile[_MAX_PATH] = '\0';
if(!RandSeed->count)
iRandSeed = -1;
else
{
iRandSeed = RandSeed->ival[0];
if(iRandSeed < 0 || iRandSeed > 32767)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Random seed specified as '-s%d' must be between 0 and 32767",iRandSeed);
exit(1);
}
}
break;
}
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Processing parameters:");
switch(iMode) {
case 0:
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Mode: 0 (randomise genome K-mers)");
for(Idx=0; Idx < NumInFileSpecs; Idx++)
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Use frequency compositions from these genome multifasta file(s) (%d): '%s'",Idx+1,pszInFiles[Idx]);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Maintain K-mer composition of length: %d",KMerLen);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Genome output file: '%s'",szOutputFile);
if(iRandSeed >= 0)
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Random seed: %d",iRandSeed);
else
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Random seed: will use current time as seed");
break;
}
gStopWatch.Start();
#ifdef _WIN32
SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);
#endif
Rslt = GenerateRandFasta(iMode,KMerLen,NumInFileSpecs,pszInFiles,szOutputFile,iRandSeed);
Rslt = Rslt >=0 ? 0 : 1;
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Exit code: %d Total processing time: %s",Rslt,gStopWatch.Read());
exit(Rslt);
}
else
{
printf("\n%s Kanga randomise genome K-mers, Version %s\n",gszProcName,cpszProgVer);
arg_print_errors(stdout,end,gszProcName);
arg_print_syntax(stdout,argtable,"\nUse '-h' to view option and parameter usage\n");
exit(1);
}
return 0;
}
int _tmain(int argc, char* argv[])
{
// determine my process name
_splitpath(argv[0],NULL,NULL,gszProcName,NULL);
#else
int
main(int argc, const char** argv)
{
// determine my process name
CUtility::splitpath((char *)argv[0],NULL,gszProcName);
#endif
int iScreenLogLevel; // level of screen diagnostics
int iFileLogLevel; // level of file diagnostics
char szLogFile[_MAX_PATH]; // write diagnostics to this file
int Rslt;
bool bSkipFirst; // true if first line contains header and should be skipped
int iMinLength; // core elements must be of at least this length
int iMaxLength; // and no longer than this length
char szInLociFile[_MAX_PATH]; // input element loci from this file
char szInSeqFile[_MAX_PATH]; // input bioseq file containing assembly
char szRsltsFile[_MAX_PATH]; // output stats to this file
// command line args
struct arg_lit *help = arg_lit0("hH","help", "print this help and exit");
struct arg_lit *version = arg_lit0("v","version,ver", "print version information and exit");
struct arg_int *FileLogLevel=arg_int0("f", "FileLogLevel", "<int>","Level of diagnostics written to logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug");
struct arg_int *ScreenLogLevel=arg_int0("S", "ScreenLogLevel", "<int>","Level of diagnostics written to logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug");
struct arg_file *LogFile = arg_file0("F","log","<file>", "diagnostics log file");
struct arg_file *InLociFile = arg_file1("i","inloci","<file>", "element loci CSV file");
struct arg_file *InSeqFile = arg_file1("I","assembly","<file>", "genome assembly bioseq file");
struct arg_file *RsltsFile = arg_file1("o","output","<file>", "output file");
struct arg_lit *SkipFirst = arg_lit0("x","skipfirst", "skip first line of CSV - header line");
struct arg_int *MinLength = arg_int0("l","minlength","<int>", "minimum element length (default 10)");
struct arg_int *MaxLength = arg_int0("L","maxlength","<int>", "maximum element length (default 1000000000)");
struct arg_end *end = arg_end(20);
void *argtable[] = {help,version,FileLogLevel,ScreenLogLevel,LogFile,
InLociFile,InSeqFile,RsltsFile,SkipFirst,MinLength,MaxLength,
end};
char **pAllArgs;
int argerrors;
argerrors = CUtility::arg_parsefromfile(argc,(char **)argv,&pAllArgs);
if(argerrors >= 0)
argerrors = arg_parse(argerrors,pAllArgs,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("\n%s csv2stats, Version %s\nOptions ---\n", gszProcName,cpszProgVer);
arg_print_syntax(stdout,argtable,"\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
printf("\nNote: Parameters can be entered into a parameter file, one parameter per line.");
printf("\n To invoke this parameter file then precede its name with '@'");
printf("\n e.g. %s @myparams.txt\n\n",gszProcName);
exit(1);
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0)
{
printf("\n%s Version %s\n",gszProcName,cpszProgVer);
exit(1);
}
if (!argerrors)
{
if(FileLogLevel->count && !LogFile->count)
{
printf("\nError: FileLogLevel '-f%d' specified but no logfile '-F<logfile>'",FileLogLevel->ival[0]);
exit(1);
}
iScreenLogLevel = iFileLogLevel = FileLogLevel->count ? FileLogLevel->ival[0] : eDLInfo;
if(iFileLogLevel < eDLNone || iFileLogLevel > eDLDebug)
{
printf("\nError: FileLogLevel '-l%d' specified outside of range %d..%d",iFileLogLevel,eDLNone,eDLDebug);
exit(1);
}
if(LogFile->count)
{
strncpy(szLogFile,LogFile->filename[0],_MAX_PATH);
szLogFile[_MAX_PATH-1] = '\0';
}
else
{
iFileLogLevel = eDLNone;
szLogFile[0] = '\0';
}
bSkipFirst = SkipFirst->count ? true : false;
iMinLength = MinLength->count ? MinLength->ival[0] : cDfltMinLengthRange;
if(iMinLength < 1 || iMinLength > cMaxLengthRange)
{
printf("Error: Mininum element length '-l%d' is not in range 1..%d",iMinLength,cMaxLengthRange);
exit(1);
}
iMaxLength = MaxLength->count ? MaxLength->ival[0] : cMaxLengthRange;
if(iMaxLength < iMinLength || iMaxLength > cMaxLengthRange)
{
printf("Error: Maximum element length '-L%d' is not in range %d..%d",iMaxLength,iMinLength,cMaxLengthRange);
exit(1);
}
strncpy(szInLociFile,InLociFile->filename[0],_MAX_PATH);
szInLociFile[_MAX_PATH-1] = '\0';
strncpy(szInSeqFile,InSeqFile->filename[0],_MAX_PATH);
szInSeqFile[_MAX_PATH-1] = '\0';
strncpy(szRsltsFile,RsltsFile->filename[0],_MAX_PATH);
szRsltsFile[_MAX_PATH-1] = '\0';
// now that command parameters have been parsed then initialise diagnostics log system
if(!gDiagnostics.Open(szLogFile,(etDiagLevel)iScreenLogLevel,(etDiagLevel)iFileLogLevel,true))
{
printf("\nError: Unable to start diagnostics subsystem.");
if(szLogFile[0] != '\0')
printf(" Most likely cause is that logfile '%s' can't be opened/created",szLogFile);
exit(1);
}
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Version: %s Processing parameters:",cpszProgVer);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Input CSV element loci file: '%s'",szInLociFile);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Input bioseq genome assembly file: '%s'",szInSeqFile);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output to file: '%s'",szRsltsFile);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"First line contains header: %s",bSkipFirst ? "yes" : "no");
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Minimum element length: %d",iMinLength);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Maximum element length: %d",iMaxLength);
#ifdef _WIN32
SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);
#endif
// processing here...
Rslt = Process(bSkipFirst,iMinLength,iMaxLength,szInLociFile,szInSeqFile,szRsltsFile);
gStopWatch.Stop();
Rslt = Rslt >=0 ? 0 : 1;
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Exit code: %d Total processing time: %s",Rslt,gStopWatch.Read());
exit(Rslt);
}
else
{
printf("\n%s csv2stats, Version %s\n",gszProcName,cpszProgVer);
arg_print_errors(stdout,end,gszProcName);
arg_print_syntax(stdout,argtable,"\nUse '-h' to view option and parameter usage\n");
exit(1);
}
}
int genkmarkers(int argc, char* argv[])
{
// determine my process name
_splitpath(argv[0],NULL,NULL,gszProcName,NULL);
#else
int
genkmarkers(int argc, char** argv)
{
// determine my process name
CUtility::splitpath((char *)argv[0],NULL,gszProcName);
#endif
int iScreenLogLevel; // level of screen diagnostics
int iFileLogLevel; // level of file diagnostics
char szLogFile[_MAX_PATH]; // write diagnostics to this file
int Rslt = 0; // function result code >= 0 represents success, < 0 on failure
int NumberOfProcessors; // number of installed CPUs
int NumThreads; // number of threads (0 defaults to number of CPUs)
int PMode; // processing mode
int KMerLen; // this length K-mers
int PrefixLen; // inter-cultivar shared prefix length
int SuffixLen; // cultivar specific suffix length
int MinWithPrefix; // minimum number of cultivars required to have the shared prefix
int MinHamming; // must be at least this Hamming away from any other K-mer in other species
char szCultivarName[cMaxDatasetSpeciesChrom+1]; // cultivar name
char szPartialCultivarsList[(cMaxDatasetSpeciesChrom + 10) * cMaxTargCultivarChroms]; // individual species parsed from this comma/tab/space separated list
int NumPartialCultivars; // there are this many pseudo chromosomes for targeted cultivar for which K-mer markers are required
char *pszPartialCultivars[cMaxTargCultivarChroms+1]; // pseudo chromosome names which identify targeted cultivar
char szSfxPseudoGenome[_MAX_PATH]; // contains assembly + suffix array over all psuedo-chromosomes for all cultivars
char szMarkerFile[_MAX_PATH]; // output potential markers to this file
char szMarkerReadsFile[_MAX_PATH]; // output reads containing potential markers to this file
char szSQLiteDatabase[_MAX_PATH]; // results summaries to this SQLite file
char szExperimentName[cMaxDatasetSpeciesChrom+1]; // experiment name
char szExperimentDescr[1000]; // describes experiment
// command line args
struct arg_lit *help = arg_lit0("h","help", "Print this help and exit");
struct arg_lit *version = arg_lit0("v","version,ver", "Print version information and exit");
struct arg_int *FileLogLevel=arg_int0("f", "FileLogLevel", "<int>","Level of diagnostics written to screen and logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug");
struct arg_file *LogFile = arg_file0("F","log","<file>", "Diagnostics log file");
struct arg_int *pmode = arg_int0("m","mode","<int>", "Processing mode : 0 - default with K-mer extension, 1 - no K-mer extension, 2 - inter-cultivar shared prefix sequences ");
struct arg_int *kmerlen = arg_int0("k","kmer","<int>", "Cultivar specific K-mers of this length (default 50, range 25..100)");
struct arg_int *prefixlen = arg_int0("p","prefixlen","<int>", "Cultivar specific K-mers to contain inter-cultivar shared prefix sequences of this length (Mode 2 only");
struct arg_int *minwithprefix = arg_int0("s","minshared","<int>","Inter-cultivar shared prefix sequences must be present in this many cultivars (Mode 2 only, default all)");
struct arg_int *minhamming = arg_int0("K","minhamming","<int>", "Minimum Hamming separation distance in other non-target cultivars (default 2, range 1..5)");
struct arg_str *cultivar = arg_str1("c","cultivar","<str>", "Cultivar name to associate with identified marker K-mers");
struct arg_str *chromnames = arg_str1("C","chromnames","<str>", "Comma/space separated list of pseudo-chrom names specific to cultivar for which markers are required");
struct arg_file *infile = arg_file1("i","in","<file>", "Use this suffix indexed pseudo-chromosomes file");
struct arg_file *outfile = arg_file1("o","markers","<file>", "Output accepted marker K-mer sequences to this multifasta file");
struct arg_file *outreadsfile = arg_file0("O","markerreads","<file>", "Output reads containing accepted marker K-mers to this multifasta file");
struct arg_int *numthreads = arg_int0("T","threads","<int>", "number of processing threads 0..128 (defaults to 0 which sets threads to number of CPU cores)");
struct arg_file *summrslts = arg_file0("q","sumrslts","<file>", "Output results summary to this SQLite3 database file");
struct arg_str *experimentname = arg_str0("w","experimentname","<str>", "experiment name SQLite3 database file");
struct arg_str *experimentdescr = arg_str0("W","experimentdescr","<str>", "experiment description SQLite3 database file");
struct arg_end *end = arg_end(200);
void *argtable[] = {help,version,FileLogLevel,LogFile,
summrslts,experimentname,experimentdescr,
pmode,kmerlen,prefixlen,minwithprefix,minhamming,cultivar,chromnames,infile,outfile,outreadsfile,
numthreads,
end};
char **pAllArgs;
int argerrors;
argerrors = CUtility::arg_parsefromfile(argc,(char **)argv,&pAllArgs);
if(argerrors >= 0)
argerrors = arg_parse(argerrors,pAllArgs,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("\n%s %s %s, Version %s\nOptions ---\n", gszProcName,gpszSubProcess->pszName,gpszSubProcess->pszFullDescr,cpszProgVer);
arg_print_syntax(stdout,argtable,"\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
printf("\nNote: Parameters can be entered into a parameter file, one parameter per line.");
printf("\n To invoke this parameter file then precede its name with '@'");
printf("\n e.g. %s %s @myparams.txt\n",gszProcName,gpszSubProcess->pszName);
printf("\nPlease report any issues regarding usage of %s at https://github.com/csiro-crop-informatics/biokanga/issues\n\n",gszProcName);
return(1);
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0)
{
printf("\n%s %s Version %s\n",gszProcName,gpszSubProcess->pszName,cpszProgVer);
return(1);
}
if (!argerrors)
{
if(FileLogLevel->count && !LogFile->count)
{
printf("\nError: FileLogLevel '-f%d' specified but no logfile '-F<logfile>\n'",FileLogLevel->ival[0]);
return(1);
}
iScreenLogLevel = iFileLogLevel = FileLogLevel->count ? FileLogLevel->ival[0] : eDLInfo;
if(iFileLogLevel < eDLNone || iFileLogLevel > eDLDebug)
{
printf("\nError: FileLogLevel '-l%d' specified outside of range %d..%d\n",iFileLogLevel,eDLNone,eDLDebug);
return(1);
}
if(LogFile->count)
{
strncpy(szLogFile,LogFile->filename[0],_MAX_PATH);
szLogFile[_MAX_PATH-1] = '\0';
}
else
{
iFileLogLevel = eDLNone;
szLogFile[0] = '\0';
}
// now that log parameters have been parsed then initialise diagnostics log system
if(!gDiagnostics.Open(szLogFile,(etDiagLevel)iScreenLogLevel,(etDiagLevel)iFileLogLevel,true))
{
printf("\nError: Unable to start diagnostics subsystem\n");
if(szLogFile[0] != '\0')
printf(" Most likely cause is that logfile '%s' can't be opened/created\n",szLogFile);
return(1);
}
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Subprocess %s Version %s starting",gpszSubProcess->pszName,cpszProgVer);
gExperimentID = 0;
gProcessID = 0;
gProcessingID = 0;
szSQLiteDatabase[0] = '\0';
szExperimentName[0] = '\0';
szExperimentDescr[0] = '\0';
if(experimentname->count)
{
strncpy(szExperimentName,experimentname->sval[0],sizeof(szExperimentName));
szExperimentName[sizeof(szExperimentName)-1] = '\0';
CUtility::TrimQuotedWhitespcExtd(szExperimentName);
CUtility::ReduceWhitespace(szExperimentName);
}
else
szExperimentName[0] = '\0';
gExperimentID = 0;
gProcessID = 0;
gProcessingID = 0;
szSQLiteDatabase[0] = '\0';
szExperimentDescr[0] = '\0';
if(summrslts->count)
{
strncpy(szSQLiteDatabase,summrslts->filename[0],sizeof(szSQLiteDatabase)-1);
szSQLiteDatabase[sizeof(szSQLiteDatabase)-1] = '\0';
CUtility::TrimQuotedWhitespcExtd(szSQLiteDatabase);
if(strlen(szSQLiteDatabase) < 1)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite database specified with '-q<filespec>' option");
return(1);
}
if(strlen(szExperimentName) < 1)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite experiment name specified with '-w<str>' option");
return(1);
}
if(experimentdescr->count)
{
strncpy(szExperimentDescr,experimentdescr->sval[0],sizeof(szExperimentDescr)-1);
szExperimentDescr[sizeof(szExperimentDescr)-1] = '\0';
CUtility::TrimQuotedWhitespcExtd(szExperimentDescr);
}
if(strlen(szExperimentDescr) < 1)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: After removal of whitespace, no SQLite experiment description specified with '-W<str>' option");
return(1);
}
gExperimentID = gSQLiteSummaries.StartExperiment(szSQLiteDatabase,false,true,szExperimentName,szExperimentName,szExperimentDescr);
if(gExperimentID < 1)
return(1);
gProcessID = gSQLiteSummaries.AddProcess((char *)gpszSubProcess->pszName,(char *)gpszSubProcess->pszName,(char *)gpszSubProcess->pszFullDescr);
if(gProcessID < 1)
return(1);
gProcessingID = gSQLiteSummaries.StartProcessing(gExperimentID,gProcessID,(char *)cpszProgVer);
if(gProcessingID < 1)
return(1);
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Initialised SQLite database '%s' for results summary collection",szSQLiteDatabase);
gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database experiment identifier for '%s' is %d",szExperimentName,gExperimentID);
gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database process identifier for '%s' is %d",(char *)gpszSubProcess->pszName,gProcessID);
gDiagnostics.DiagOut(eDLInfo,gszProcName,"SQLite database processing instance identifier is %d",gProcessingID);
}
else
{
szSQLiteDatabase[0] = '\0';
szExperimentDescr[0] = '\0';
}
// show user current resource limits
#ifndef _WIN32
gDiagnostics.DiagOut(eDLInfo, gszProcName, "Resources: %s",CUtility::ReportResourceLimits());
#endif
#ifdef _WIN32
SYSTEM_INFO SystemInfo;
GetSystemInfo(&SystemInfo);
NumberOfProcessors = SystemInfo.dwNumberOfProcessors;
#else
NumberOfProcessors = sysconf(_SC_NPROCESSORS_CONF);
#endif
int MaxAllowedThreads = min(cMaxWorkerThreads,NumberOfProcessors); // limit to be at most cMaxWorkerThreads
if((NumThreads = numthreads->count ? numthreads->ival[0] : MaxAllowedThreads)==0)
NumThreads = MaxAllowedThreads;
if(NumThreads < 0 || NumThreads > MaxAllowedThreads)
{
gDiagnostics.DiagOut(eDLWarn,gszProcName,"Warning: Number of threads '-T%d' specified was outside of range %d..%d",NumThreads,1,MaxAllowedThreads);
gDiagnostics.DiagOut(eDLWarn,gszProcName,"Warning: Defaulting number of threads to %d",MaxAllowedThreads);
NumThreads = MaxAllowedThreads;
}
PMode = (etPMode)(pmode->count ? pmode->ival[0] : ePMExtdKMers);
if(PMode < ePMExtdKMers || PMode >= ePMplaceholder)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Processing mode '-m%d' specified outside of range %d..%d\n",PMode,ePMExtdKMers,(int)ePMplaceholder-1);
exit(1);
}
KMerLen = kmerlen->count ? kmerlen->ival[0] : cDfltKMerLen;
if(KMerLen < cMinKMerLen || KMerLen > cMaxKMerLen)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: K-mer core length '-k%d' must be in range %d..%d",KMerLen,cMinKMerLen,cMaxKMerLen);
return(1);
}
if(PMode == 2)
{
PrefixLen = prefixlen->count ? prefixlen->ival[0] : KMerLen/2;
if(PrefixLen < cMinKMerLen/2 || PrefixLen > KMerLen-(cMinKMerLen/2))
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Prefix length '-p%d' must be in range %d..%d",KMerLen,cMinKMerLen/2,KMerLen-(cMinKMerLen/2));
return(1);
}
SuffixLen = KMerLen - PrefixLen;
MinWithPrefix = minwithprefix->count ? minwithprefix->ival[0] : 0;
if(MinWithPrefix != 0 && MinWithPrefix < 1)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Minimum cultivars sharing prefix sequence '-s%d' must be either 0 (all) or at least 1",MinWithPrefix);
return(1);
}
}
MinHamming = minhamming->count ? minhamming->ival[0] : cDfltHamming;
if(MinHamming < cMinHamming || MinHamming > cMaxHamming)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Minimum Hamming separation '-K%d' must be in range %d..%d",MinHamming,cMinHamming,cMaxHamming);
return(1);
}
strncpy(szCultivarName,cultivar->sval[0],cMaxDatasetSpeciesChrom);
szCultivarName[cMaxDatasetSpeciesChrom]= '\0';
CUtility::TrimQuotedWhitespcExtd(szCultivarName);
if(strlen(szCultivarName) < 1)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Expected cultivar name '-c<name>' is empty");
return(1);
}
strncpy(szPartialCultivarsList,chromnames->sval[0],sizeof(szPartialCultivarsList));
szPartialCultivarsList[sizeof(szPartialCultivarsList)-1] = '\0';
CUtility::TrimQuotedWhitespcExtd(szPartialCultivarsList);
CUtility::ReduceWhitespace(szPartialCultivarsList);
char *pChr = szPartialCultivarsList;
char *pStartChr;
char Chr;
int CurSpeciesLen;
NumPartialCultivars=0;
CurSpeciesLen = 0;
pStartChr = pChr;
while((Chr = *pChr++) != '\0')
{
if(Chr == ' ' || Chr == '\t' || Chr == ',') // treat any of these as delimiters
{
pChr[-1] = '\0';
if(CurSpeciesLen != 0)
{
pszPartialCultivars[NumPartialCultivars++] = pStartChr;
CurSpeciesLen = 0;
}
pStartChr = pChr;
continue;
}
CurSpeciesLen += 1;
}
if(CurSpeciesLen)
pszPartialCultivars[NumPartialCultivars++] = pStartChr;
if(!NumPartialCultivars)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Expected at least one ('-C<names>') targeted cultivar chromosme name");
return(1);
}
strcpy(szSfxPseudoGenome,infile->filename[0]);
CUtility::TrimQuotedWhitespcExtd(szSfxPseudoGenome);
if(strlen(szSfxPseudoGenome) < 1)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Expected input pseudo-genome suffix array filename '-i<name>' is empty");
return(1);
}
strcpy(szMarkerFile,outfile->filename[0]);
CUtility::TrimQuotedWhitespcExtd(szMarkerFile);
if(strlen(szMarkerFile) < 1)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Expected marker file to generate filename '-o<name>' is empty");
return(1);
}
if(outreadsfile->count)
{
strcpy(szMarkerReadsFile,outreadsfile->filename[0]);
CUtility::TrimQuotedWhitespcExtd(szMarkerReadsFile);
if(strlen(szMarkerReadsFile) < 1)
{
gDiagnostics.DiagOut(eDLFatal,gszProcName,"Error: Reads containing markers filename '-O<name>' is empty");
return(1);
}
}
else
szMarkerReadsFile[0] = '\0';
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Processing parameters:");
const char *pszDescr;
switch(PMode) {
case ePMExtdKMers:
pszDescr = "Extended K-mer markers";
break;
case ePMNoExtdKMers:
pszDescr = "Non-extended K-mer markers";
break;
case ePMPrefixKMers:
pszDescr = "K-mers to share prefix sequence with other cultivars";
break;
}
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Processing mode is : '%s'",pszDescr);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Targeted cultivar name : '%s'",szCultivarName);
for(int Idx = 0; Idx < NumPartialCultivars; Idx++)
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Targeted cultivar chromosome name (%d) : '%s'", Idx + 1,pszPartialCultivars[Idx]);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Core K-mer length : %d",KMerLen);
if(PMode == ePMPrefixKMers)
{
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Inter-cultivar shared prefix sequence length : %d",PrefixLen);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Cultivar specific suffix sequence length : %d",SuffixLen);
if(MinWithPrefix)
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Min number cultivars sharing prefix : %d",MinWithPrefix);
else
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Min number cultivars sharing prefix : 'All'");
}
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Minimum Hamming separation : %d",MinHamming);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Input indexed pseudo-genome file: '%s'",szSfxPseudoGenome);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Write marker K-mers to file: '%s'",szMarkerFile);
if(szMarkerReadsFile[0] != '\0')
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Write marker containing reads to file: '%s'",szMarkerReadsFile);
if(szExperimentName[0] != '\0')
gDiagnostics.DiagOutMsgOnly(eDLInfo,"This processing reference: %s",szExperimentName);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Number of processing threads: %d",NumThreads);
if(gExperimentID > 0)
{
int ParamID;
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szLogFile),"log",szLogFile);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(PMode),"mode",&PMode);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(KMerLen),"kmer",&KMerLen);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(PrefixLen),"prefixlen",&PrefixLen);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(SuffixLen),"suffixlen",&SuffixLen);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(MinWithPrefix),"minwithprefix",&MinWithPrefix);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(MinHamming),"minhamming",&MinHamming);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(NumThreads),"threads",&NumThreads);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(NumberOfProcessors),"cpus",&NumberOfProcessors);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szCultivarName),"cultivar",szCultivarName);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTInt32,sizeof(NumPartialCultivars),"NumPartialCultivars",&NumPartialCultivars);
for(int Idx = 0; Idx < NumPartialCultivars; Idx++)
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(pszPartialCultivars[Idx]),"chromnames",pszPartialCultivars[Idx]);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szSfxPseudoGenome),"in",szSfxPseudoGenome);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szMarkerFile),"markers",szMarkerFile);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szMarkerReadsFile),"markerreads",szMarkerReadsFile);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szSQLiteDatabase),"sumrslts",szSQLiteDatabase);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szExperimentName),"experimentname",szExperimentName);
ParamID = gSQLiteSummaries.AddParameter(gProcessingID,ePTText,(int)strlen(szExperimentDescr),"experimentdescr",szExperimentDescr);
}
#ifdef _WIN32
SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);
#endif
gStopWatch.Start();
Rslt = LocMarkers((etPMode)PMode,KMerLen,PrefixLen,SuffixLen,MinWithPrefix,MinHamming,szCultivarName,NumPartialCultivars,pszPartialCultivars,szSfxPseudoGenome,szMarkerFile,szMarkerReadsFile,NumThreads);
Rslt = Rslt >=0 ? 0 : 1;
if(gExperimentID > 0)
{
if(gProcessingID)
gSQLiteSummaries.EndProcessing(gProcessingID,Rslt);
gSQLiteSummaries.EndExperiment(gExperimentID);
}
gStopWatch.Stop();
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Exit code: %d Total processing time: %s",Rslt,gStopWatch.Read());
return(Rslt);
}
else
{
printf("\n%s %s %s, Version %s\n", gszProcName,gpszSubProcess->pszName,gpszSubProcess->pszFullDescr,cpszProgVer);
arg_print_errors(stdout,end,gszProcName);
arg_print_syntax(stdout,argtable,"\nUse '-h' to view option and parameter usage\n");
return(1);
}
return 0;
}
int _tmain(int argc, char* argv[])
{
// determine my process name
_splitpath(argv[0],NULL,NULL,gszProcName,NULL);
#else
int
main(int argc, const char** argv)
{
// determine my process name
CUtility::splitpath((char *)argv[0],NULL,gszProcName);
#endif
int iScreenLogLevel; // level of screen diagnostics
int iFileLogLevel; // level of file diagnostics
char szLogFile[_MAX_PATH]; // write diagnostics to this file
int Rslt;
etFMode FMode; // format output mode
char szOutputFileSpec[_MAX_PATH];
char szInputFileSpec[_MAX_PATH];
// command line args
struct arg_lit *help = arg_lit0("h","help", "print this help and exit");
struct arg_lit *version = arg_lit0("v","version,ver", "print version information and exit");
struct arg_int *FileLogLevel=arg_int0("f", "FileLogLevel", "<int>","Level of diagnostics written to screen and logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug");
struct arg_file *LogFile = arg_file0("F","log","<file>", "diagnostics log file");
struct arg_int *format = arg_int0("M","format","<int>", "output format: 0 - multifasta, 1 - CSV format only, 2 - BED format, 3 - XML entries only (default: 0)");
struct arg_file *InFile = arg_file1("i","input","<file>", "input from bioseq files");
struct arg_file *OutFile = arg_file1("o","result","<file>", "output entry dump file");
struct arg_end *end = arg_end(20);
void *argtable[] = {help,version,FileLogLevel,LogFile,LogFile,format,InFile,OutFile,end};
char **pAllArgs;
int argerrors;
argerrors = CUtility::arg_parsefromfile(argc,(char **)argv,&pAllArgs);
if(argerrors >= 0)
argerrors = arg_parse(argerrors,pAllArgs,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("\n%s Dump biosequence (generated by genbioseq) file contents, Version %s\nOptions ---\n", gszProcName,cpszProgVer);
arg_print_syntax(stdout,argtable,"\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
printf("\nNote: Parameters can be entered into a parameter file, one parameter per line.");
printf("\n To invoke this parameter file then precede its name with '@'");
printf("\n e.g. %s @myparams.txt\n",gszProcName);
printf("\nPlease report any issues regarding usage of %s at https://github.com/csiro-crop-informatics/biokanga/issues\n\n",gszProcName);
exit(1);
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0)
{
printf("\n%s Version %s\n",gszProcName,cpszProgVer);
exit(1);
}
if (!argerrors)
{
if(FileLogLevel->count && !LogFile->count)
{
printf("\nError: FileLogLevel '-f%d' specified but no logfile '-F<logfile>'",FileLogLevel->ival[0]);
exit(1);
}
iScreenLogLevel = iFileLogLevel = FileLogLevel->count ? FileLogLevel->ival[0] : eDLInfo;
if(iFileLogLevel < eDLNone || iFileLogLevel > eDLDebug)
{
printf("\nError: FileLogLevel '-l%d' specified outside of range %d..%d",iFileLogLevel,eDLNone,eDLDebug);
exit(1);
}
if(LogFile->count)
{
strncpy(szLogFile,LogFile->filename[0],_MAX_PATH);
szLogFile[_MAX_PATH-1] = '\0';
}
else
{
iFileLogLevel = eDLNone;
szLogFile[0] = '\0';
}
FMode = (etFMode)(format->count ? format->ival[0] : eFMdefault);
if(FMode < eFMdefault || FMode >= eFMplaceholder)
{
printf("\nError: Requested output format '-M%d' not supported, must be in range %d..%d",FMode,eFMdefault,eFMplaceholder-1);
exit(1);
}
strcpy(szInputFileSpec,InFile->filename[0]);
strcpy(szOutputFileSpec,OutFile->filename[0]);
// now that command parameters have been parsed then initialise diagnostics log system
if(!gDiagnostics.Open(szLogFile,(etDiagLevel)iScreenLogLevel,(etDiagLevel)iFileLogLevel,true))
{
printf("\nError: Unable to start diagnostics subsystem.");
if(szLogFile[0] != '\0')
printf(" Most likely cause is that logfile '%s' can't be opened/created",szLogFile);
exit(1);
}
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Version: %s Processing parameters:",cpszProgVer);
const char *pszDescr;
switch(FMode) {
case eFMdefault: // default is for multifasta
pszDescr = "Multifasta";
break;
case eFMcsv: // CSV entries
pszDescr = "CSV format";
break;
case eFMbed: // BED entries
pszDescr = "BED format";
break;
case eFMxml: // XML entries
pszDescr = "XML format";
break;
}
gDiagnostics.DiagOut(eDLInfo,gszProcName,"dump output format: %s",pszDescr);
gDiagnostics.DiagOut(eDLInfo,gszProcName,"input biosequence file: '%s'",szInputFileSpec);
gDiagnostics.DiagOut(eDLInfo,gszProcName,"output to file: '%s'",szOutputFileSpec);
gStopWatch.Start();
Rslt = Process(szInputFileSpec,szOutputFileSpec,FMode);
gStopWatch.Stop();
Rslt = Rslt >=0 ? 0 : 1;
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Exit code: %d Total processing time: %s",Rslt,gStopWatch.Read());
exit(Rslt);
}
else
{
printf("\n%s Dump biosequence (generated by genbioseq) file contents, Version %s\n",gszProcName,cpszProgVer);
arg_print_errors(stdout,end,gszProcName);
arg_print_syntax(stdout,argtable,"\nUse '-h' to view option and parameter usage\n");
exit(1);
}
}
int main(int argc, char* argv[])
{
// Define our variables.
int nerrors, i;
int32_t saved = 0; // The number of words saved during compression and optimization.
struct errinfo* errval;
const char* prepend = "error: ";
const char* warnprefix = "no-";
int msglen;
char* msg;
int target;
// Define arguments.
struct arg_lit* show_help = arg_lit0("h", "help", "Show this help.");
struct arg_str* target_arg = arg_str0("l", "link-as", "target", "Link as the specified object, can be 'image', 'static' or 'kernel'.");
struct arg_file* symbol_file = arg_file0("s", "symbols", "<file>", "Produce a combined symbol file (~triples memory usage!).");
struct arg_str* symbol_ext = arg_str0(NULL, "symbol-extension", "ext", "When -s is used, specifies the extension for symbol files. Defaults to \"dsym16\".");
struct arg_file* input_files = arg_filen(NULL, NULL, "<file>", 1, 100, "The input object files.");
struct arg_file* output_file = arg_file1("o", "output", "<file>", "The output file (or - to send to standard output).");
struct arg_file* kernel_file = arg_file0("k", "kernel", "<file>", "Directly link in the specified kernel.");
struct arg_file* jumplist_file = arg_file0("j", "jumplist", "<file>", "Link against the specified jumplist.");
struct arg_str* warning_policies = arg_strn("W", NULL, "policy", 0, _WARN_COUNT * 2 + 10, "Modify warning policies.");
struct arg_lit* keep_output_arg = arg_lit0(NULL, "keep-outputs", "Keep the .OUTPUT entries in the final static library (used for stdlib).");
struct arg_lit* little_endian_mode = arg_lit0(NULL, "little-endian", "Use little endian serialization (for compatibility with older versions).");
struct arg_lit* no_short_literals_arg = arg_lit0(NULL, "no-short-literals", "Do not compress literals to short literals.");
struct arg_int* opt_level = arg_int0("O", NULL, "<level>", "The optimization level.");
struct arg_lit* opt_mode = arg_lit0("S", NULL, "Favour runtime speed over size when optimizing.");
struct arg_lit* verbose = arg_litn("v", NULL, 0, LEVEL_EVERYTHING - LEVEL_DEFAULT, "Increase verbosity.");
struct arg_lit* quiet = arg_litn("q", NULL, 0, LEVEL_DEFAULT - LEVEL_SILENT, "Decrease verbosity.");
struct arg_end* end = arg_end(20);
void* argtable[] = { show_help, target_arg, keep_output_arg, little_endian_mode, opt_level, opt_mode, no_short_literals_arg,
symbol_ext, symbol_file, kernel_file, jumplist_file, warning_policies, output_file, input_files, verbose, quiet, end
};
// Parse arguments.
nerrors = arg_parse(argc, argv, argtable);
version_print(bautofree(bfromcstr("Linker")));
if (nerrors != 0 || show_help->count != 0)
{
if (show_help->count != 0)
arg_print_errors(stdout, end, "linker");
printd(LEVEL_DEFAULT, "syntax:\n dtld");
arg_print_syntax(stderr, argtable, "\n");
printd(LEVEL_DEFAULT, "options:\n");
arg_print_glossary(stderr, argtable, " %-25s %s\n");
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
return 1;
}
// Set verbosity level.
debug_setlevel(LEVEL_DEFAULT + verbose->count - quiet->count);
// Set global path variable.
osutil_setarg0(bautofree(bfromcstr(argv[0])));
// Set endianness.
isetmode(little_endian_mode->count == 0 ? IMODE_BIG : IMODE_LITTLE);
// Set up warning policies.
dsetwarnpolicy(warning_policies);
// Set up error handling.
if (dsethalt())
{
errval = derrinfo();
// FIXME: Use bstrings here.
msglen = strlen(derrstr[errval->errid]) + strlen(prepend) + 1;
msg = malloc(msglen);
memset(msg, '\0', msglen);
strcat(msg, prepend);
strcat(msg, derrstr[errval->errid]);
printd(LEVEL_ERROR, msg, errval->errdata);
// Handle the error.
printd(LEVEL_ERROR, "linker: error occurred.\n");
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
return 1;
}
// Check to make sure target is correct.
if (target_arg->count == 0)
target = IMAGE_APPLICATION;
else
{
if (strcmp(target_arg->sval[0], "image") == 0)
target = IMAGE_APPLICATION;
else if (strcmp(target_arg->sval[0], "static") == 0)
target = IMAGE_STATIC_LIBRARY;
else if (strcmp(target_arg->sval[0], "kernel") == 0)
target = IMAGE_KERNEL;
else
{
// Invalid option.
dhalt(ERR_INVALID_TARGET_NAME, NULL);
}
}
// Load all passed objects and use linker bin system to
// produce result.
bins_init();
for (i = 0; i < input_files->count; i++)
if (!bins_load(bautofree(bfromcstr(input_files->filename[i])), symbol_file->count > 0, (symbol_file->count > 0 && symbol_ext->count > 0) ? symbol_ext->sval[0] : "dsym16"))
// Failed to load one of the input files.
dhalt(ERR_BIN_LOAD_FAILED, input_files->filename[i]);
bins_associate();
bins_sectionize();
bins_flatten(bautofree(bfromcstr("output")));
if (target == IMAGE_KERNEL)
bins_write_jump();
saved = bins_optimize(
opt_mode->count == 0 ? OPTIMIZE_SIZE : OPTIMIZE_SPEED,
opt_level->count == 0 ? OPTIMIZE_NONE : opt_level->ival[0]);
if (no_short_literals_arg->count == 0 && target != IMAGE_STATIC_LIBRARY)
saved += bins_compress();
else if (no_short_literals_arg->count == 0)
dwarn(WARN_SKIPPING_SHORT_LITERALS_TYPE, NULL);
else
dwarn(WARN_SKIPPING_SHORT_LITERALS_REQUEST, NULL);
bins_resolve(
target == IMAGE_STATIC_LIBRARY,
target == IMAGE_STATIC_LIBRARY);
bins_save(
bautofree(bfromcstr("output")),
bautofree(bfromcstr(output_file->filename[0])),
target,
keep_output_arg->count > 0,
symbol_file->count > 0 ? symbol_file->filename[0] : NULL,
jumplist_file->count > 0 ? jumplist_file->filename[0] : NULL);
bins_free();
if (saved > 0)
printd(LEVEL_DEFAULT, "linker: saved %i words during optimization.\n", saved);
else if (saved < 0)
printd(LEVEL_DEFAULT, "linker: increased by %i words during optimization.\n", -saved);
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
return 0;
}
int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::set_thread_priority_safe();
size_t rxshm_size, txshm_size;
bool mimic_active;
float mimic_delay;
unsigned int iSide, iSwing; // often used loop variables
int32_t rx_worker_status = 0;
int32_t clrfreq_rx_worker_status = 0;
int32_t mute_output = 0; // used if rx_worker error happends
int32_t rx_stream_reset_count = 0;
int32_t rx_stream_error_count = 0;
std::vector<sem_t> sem_rx_vec(nSwings), sem_tx_vec(nSwings);
std::vector<uint32_t> state_vec(nSwings, ST_INIT);
uint32_t swing; // = SWING0;
size_t nSamples_rx, nSamples_tx_pulse, nSamples_pause_after_rx, nSamples_auto_clear_freq, nSamples_rx_total;
size_t auto_clear_freq_available = 0;
uint32_t npulses, nerrors;
ssize_t cmd_status;
uint32_t usrp_driver_base_port, ip_part;
int32_t connect_retrys = MAX_SOCKET_RETRYS;
int32_t sockopt;
struct sockaddr_in sockaddr;
struct sockaddr_storage client_addr;
socklen_t addr_size;
uint32_t exit_driver = 0;
uint32_t tx_worker_active;
uhd::time_spec_t start_time, rx_start_time;
// vector of all pulse start times over an integration period
std::vector<uhd::time_spec_t> pulse_time_offsets;
// vector of the sample index of pulse start times over an integration period
std::vector<uint64_t> pulse_sample_idx_offsets;
boost::thread_group uhd_threads;
boost::thread_group clrfreq_threads;
// process config file for port and SHM sizes
DEBUG_PRINT("USRP_DRIVER starting to read driver_config.ini\n");
boost::property_tree::ptree pt;
boost::property_tree::ini_parser::read_ini("../driver_config.ini", pt);
// DEBUG_PRINT("USRP_DRIVER reading rxshm_size\n");
// std::cout << pt.get<std::string>("shm_settings.rxshm_size") << '\n';
rxshm_size = std::stoi(pt.get<std::string>("shm_settings.rxshm_size"));
// DEBUG_PRINT("USRP_DRIVER reading txshm_size\n");
txshm_size = std::stoi(pt.get<std::string>("shm_settings.txshm_size"));
usrp_driver_base_port = std::stoi(pt.get<std::string>("network_settings.USRPDriverPort"));
boost::property_tree::ptree pt_array;
DEBUG_PRINT("USRP_DRIVER starting to read array_config.ini\n");
boost::property_tree::ini_parser::read_ini("../array_config.ini", pt_array);
mimic_active = std::stof(pt_array.get<std::string>("mimic.mimic_active")) != 0;
mimic_delay = std::stof(pt_array.get<std::string>("mimic.mimic_delay"));
fprintf(stderr, "read from ini: mimic_active=%d, mimic_delay=%f\n", mimic_active, mimic_delay);
init_all_dirs();
// TODO also read usrp_config.ini and get antenna and side information from it. remove antenna input argument.
// process command line arguments
struct arg_lit *al_help = arg_lit0(NULL, "help", "Prints help information and then exits");
// struct arg_int *ai_ant = arg_intn("a", "antenna", NULL, 1, 2, "Antenna position index for the USRP");
struct arg_int *ai_ant_a = arg_int0("a", "antennaA", NULL, "Antenna position index for the USRP on side A");
struct arg_int *ai_ant_b = arg_int0("b", "antennaB", NULL, "Antenna position index for the USRP on side B");
struct arg_str *as_host = arg_str0("h", "host", NULL, "Hostname or IP address of USRP to control (e.g usrp1)");
struct arg_lit *al_intclk = arg_lit0("i", "intclk", "Select internal clock (default is external)");
struct arg_lit *al_interferometer = arg_lit0("x", "interferometer", "Disable tx_worker for interferometer antennas");
struct arg_end *ae_argend = arg_end(ARG_MAXERRORS);
void* argtable[] = {al_help, ai_ant_a, ai_ant_b, as_host, al_intclk, al_interferometer, ae_argend};
double txrate, rxrate, txfreq, rxfreq;
double txrate_new, rxrate_new, txfreq_new, rxfreq_new;
DEBUG_PRINT("usrp_driver debug mode enabled\n");
if (SUPRESS_UHD_PRINTS) {
uhd::msg::register_handler(&uhd_term_message_handler);
}
nerrors = arg_parse(argc,argv,argtable);
if (nerrors > 0) {
arg_print_errors(stdout,ae_argend,"usrp_driver");
exit(1);
}
if (argc == 1) {
printf("No arguments found, try running again with --help for more information.\n");
exit(1);
}
if(al_help->count > 0) {
printf("Usage: ");
arg_print_syntax(stdout,argtable,"\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0]));
return 0;
}
unsigned int nSides = ai_ant_a->count + ai_ant_b->count;
if( nSides == 0 ) {
printf("No antenna index, exiting...");
return 0;
}
if(as_host->sval == NULL) {
printf("Missing usrp host command line argument, exiting...");
return 0;
}
std::vector<int> antennaVector(nSides);
std::vector<uint64_t> channel_numbers;
// both sides
if( nSides == 2 ) {
DEBUG_PRINT("Setting side A: ant_idx %d\n",ai_ant_a->ival[0]);
antennaVector[0] = ai_ant_a->ival[0];
channel_numbers.push_back(0);
DEBUG_PRINT("Setting side B: ant_idx %d\n",ai_ant_b->ival[0]);
antennaVector[1] = ai_ant_b->ival[0];
channel_numbers.push_back(1);
} else {
// side A
if (ai_ant_a->count == 1) {
DEBUG_PRINT("Setting side A: ant_idx %d\n",ai_ant_a->ival[0]);
antennaVector[0] = ai_ant_a->ival[0];
channel_numbers.push_back(0);
// side B
} else {
DEBUG_PRINT("Setting side B: ant_idx %d\n",ai_ant_b->ival[0]);
antennaVector[0] = ai_ant_b->ival[0];
channel_numbers.push_back(1);
DEBUG_PRINT("Warning: For one side use DIO output is always on Side A!!!!!!!!!!!!!"); // TODO correct this
}
}
// pointers to shared memory
std::vector<std::vector<void *>> shm_rx_vec(nSides, std::vector<void *>( nSwings));
std::vector<std::vector<void *>> shm_tx_vec(nSides, std::vector<void *>( nSwings));
// local buffers for tx and rx
std::vector<std::vector<std::complex<int16_t>>> tx_samples(nSides, std::vector<std::complex<int16_t>>(MAX_PULSE_LENGTH,0));
std::vector<std::vector<std::complex<int16_t>>> rx_data_buffer(nSides, std::vector<std::complex<int16_t>>(0));
std::vector<std::vector<std::complex<int16_t>>> rx_auto_clear_freq(nSides, std::vector<std::complex<int16_t>>(0));
std::string usrpargs(as_host->sval[0]);
usrpargs = "addr0=" + usrpargs + ",master_clock_rate=200.0e6";
// usrpargs = "addr0=" + usrpargs + ",master_clock_rate=200.0e6,recv_frame_size=50000000";
uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(usrpargs);
// usrp->set_rx_subdev_spec(uhd::usrp::subdev_spec_t("A:A B:A"));
// usrp->set_tx_subdev_spec(uhd::usrp::subdev_spec_t("A:A B:A"));
boost::this_thread::sleep(boost::posix_time::seconds(SETUP_WAIT));
uhd::stream_args_t stream_args("sc16", "sc16");
if (usrp->get_rx_num_channels() < nSides || usrp->get_tx_num_channels() < nSides) {
DEBUG_PRINT("ERROR: Number of defined channels (%i) is smaller than avaialable channels:\n usrp->get_rx_num_channels(): %lu \n usrp->get_tx_num_channels(): %lu \n\n", nSides, usrp->get_rx_num_channels(), usrp->get_tx_num_channels());
return -1;
}
stream_args.channels = channel_numbers;
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
// TODO: retry uhd connection if fails..
// Determine port from 3rd part of ip (192.168.x.2 => port = base_port + x )
int start_idx = usrpargs.find(".");
start_idx = usrpargs.find(".", start_idx+1);
int end_idx = usrpargs.find(".", start_idx+1);
ip_part = atoi(usrpargs.substr(start_idx+1, end_idx-start_idx-1).c_str());
// initialize rxfe gpio
kodiak_init_rxfe(usrp, nSides);
// initialize other gpio on usrp
init_timing_signals(usrp, mimic_active, nSides);
//if(CAPTURE_ERRORS) {
// signal(SIGINT, siginthandler);
//}
// open shared memory buffers and semaphores created by cuda_driver.py
// for dual polarization we use antenna numbers 20 to 35 (side is always 0)
for(iSwing = 0; iSwing < nSwings; iSwing++) {
for(iSide = 0; iSide < nSides; iSide++) {
int shm_side = 0;
shm_rx_vec[iSide][iSwing] = open_sample_shm(antennaVector[iSide], RXDIR, shm_side, iSwing, rxshm_size);
shm_tx_vec[iSide][iSwing] = open_sample_shm(antennaVector[iSide], TXDIR, shm_side, iSwing, txshm_size);
DEBUG_PRINT("usrp_driver rx shm addr: %p iSide: %d iSwing: %d\n", shm_rx_vec[iSide][iSwing], iSide, iSwing);
if (antennaVector[iSide] < 19 ) { // semaphores only for antennas of first polarization TODO check if this is enough
sem_rx_vec[iSwing] = open_sample_semaphore(antennaVector[iSide], iSwing, RXDIR);
sem_tx_vec[iSwing] = open_sample_semaphore(antennaVector[iSide], iSwing, TXDIR);
}
}
}
if(al_interferometer->count > 0) {
DEBUG_PRINT("Disable tx_worker ...\n");
tx_worker_active = 0;
} else {
tx_worker_active = 1;
}
if(al_intclk->count > 0) {
usrp->set_clock_source("internal");
usrp->set_time_source("internal");
}
else {
// sync clock with external 10 MHz and PPS
DEBUG_PRINT("Set clock: external\n");
usrp->set_clock_source("external", 0);
DEBUG_PRINT("Set time: external\n");
usrp->set_time_source("external", 0);
DEBUG_PRINT("Done setting time and clock\n");
}
while(true) {
if(driversock) {
close(driverconn);
close(driversock);
}
boost::this_thread::sleep(boost::posix_time::seconds(SETUP_WAIT));
// bind to socket for communication with usrp_server.py:
driversock = socket(AF_INET, SOCK_STREAM, 0);
if(driversock < 0){
perror("opening stream socket\n");
exit(1);
}
sockopt = 1;
setsockopt(driversock, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof(int32_t));
sockaddr.sin_family = AF_INET;
// TODO: maybe limit addr to interface connected to usrp_server
sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
fprintf(stderr, "listening on port: %d\n", usrp_driver_base_port + ip_part);
sockaddr.sin_port = htons(usrp_driver_base_port + ip_part);
if( bind(driversock, (struct sockaddr *)&sockaddr, sizeof(sockaddr)) < 0){
perror("binding tx stream socket");
exit(1);
}
// wait for connection...
listen(driversock, 5);
// and accept it
fprintf(stderr, "waiting for socket connection\n");
addr_size = sizeof(client_addr);
driverconn = accept(driversock, (struct sockaddr *) &client_addr, &addr_size);
fprintf(stderr, "accepted socket connection\n");
while(true) {
// wait for transport endpoint to connect?
DEBUG_PRINT("USRP_DRIVER waiting for command\n");
uint8_t command = sock_get_cmd(driverconn, &cmd_status);
DEBUG_PRINT("USRP_DRIVER received command, status: %zu\n", cmd_status);
// see if socket is closed..
if(cmd_status == 11 || cmd_status == 0 || cmd_status < 0) {
DEBUG_PRINT("USRP_DRIVER lost connection to usrp_server, waiting for fresh connection, %d tries remaining\n", connect_retrys);
close(driversock);
if(connect_retrys-- < 0) {
exit(1);
}
sleep(1);
break;
}
connect_retrys = MAX_SOCKET_RETRYS;
switch(command) {
case USRP_SETUP: {
// receive infomation about a pulse sequence/integration period
// transmit/receive center frequenies and sampling rates
// number of tx/rx samples
// number of pulse sequences per integration period, and pulse start times
swing = sock_get_int16( driverconn);
DEBUG_PRINT("entering USRP_SETUP command (swing %d)\n", swing);
txfreq_new = sock_get_float64(driverconn);
rxfreq_new = sock_get_float64(driverconn);
txrate_new = sock_get_float64(driverconn);
rxrate_new = sock_get_float64(driverconn);
npulses = sock_get_uint32(driverconn);
nSamples_rx = sock_get_uint64(driverconn);
nSamples_pause_after_rx = sock_get_uint64(driverconn);
nSamples_auto_clear_freq = sock_get_uint64(driverconn);
nSamples_tx_pulse = sock_get_uint64(driverconn);
nSamples_rx_total = nSamples_rx + nSamples_pause_after_rx + nSamples_auto_clear_freq;
DEBUG_PRINT("USRP_SETUP number of requested rx samples: %d + %d pause + %d auto clear freq\n", (uint32_t) nSamples_rx, nSamples_pause_after_rx, nSamples_auto_clear_freq);
DEBUG_PRINT("USRP_SETUP number of requested tx samples per pulse: %d\n", (uint32_t) nSamples_tx_pulse);
DEBUG_PRINT("USRP_SETUP existing tx rate : %f (swing %d)\n", txrate, swing);
DEBUG_PRINT("USRP_SETUP requested tx rate: %f\n", txrate_new);
// resize
pulse_sample_idx_offsets.resize(npulses);
pulse_time_offsets.resize(npulses);
for(uint32_t i = 0; i < npulses; i++) {
// DEBUG_PRINT("USRP_SETUP waiting for pulse offset %d of %d\n", i+2, npulses);
pulse_sample_idx_offsets[i] = sock_get_uint64(driverconn);
// DEBUG_PRINT("USRP_SETUP received %zu pulse offset\n", pulse_sample_idx_offsets[i]);
}
DEBUG_PRINT("USRP_SETUP resize autoclear freq\n");
// RESIZE LOCAL BUFFERS
if(rx_data_buffer[0].size() < nSamples_rx_total) {
for(iSide = 0; iSide < nSides; iSide++) {
rx_data_buffer[iSide].resize(nSamples_rx_total);
}
}
DEBUG_PRINT("USRP_SETUP resize autoclear freq\n");
if(nSamples_auto_clear_freq != 0 and rx_auto_clear_freq[0].size() < nSamples_auto_clear_freq) {
for(iSide = 0; iSide < nSides; iSide++) {
rx_auto_clear_freq[iSide].resize(nSamples_auto_clear_freq);
}
}
// TODO use return argument of set_xx to save new rate/freq
// if necessary, retune USRP frequency and sampling rate
if(rxrate != rxrate_new) {
usrp->set_rx_rate(rxrate_new);
rxrate = usrp->get_rx_rate();
}
if(txrate != txrate_new) {
usrp->set_tx_rate(txrate_new);
txrate = usrp->get_tx_rate();
}
if(rxfreq != rxfreq_new) {
for(iSide = 0; iSide < nSides; iSide++) {
usrp->set_rx_freq(rxfreq_new, iSide);
}
rxfreq = usrp->get_rx_freq();
}
if(txfreq != txfreq_new) {
for(iSide = 0; iSide < nSides; iSide++) {
usrp->set_tx_freq(txfreq_new, iSide);
}
txfreq = usrp->get_tx_freq();
}
if(verbose) {
std::cout << boost::format("Actual RX Freq: %f MHz...") % (usrp->get_rx_freq()/1e6) << std::endl;
std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl;
std::cout << boost::format("Actual TX Freq: %f MHz...") % (usrp->get_tx_freq()/1e6) << std::endl;
std::cout << boost::format("Actual TX Rate: %f Msps...") % (usrp->get_tx_rate()/1e6) << std::endl;
}
// TODO: set the number of samples in a pulse. this is calculated from the pulse duration and the sampling rate
// when do we know this? after USRP_SETUP
// create local copy of transmit pulse data from shared memory
std::complex<int16_t> *shm_pulseaddr;
size_t spb = tx_stream->get_max_num_samps();
size_t pulse_bytes = sizeof(std::complex<int16_t>) * nSamples_tx_pulse;
size_t number_of_pulses = pulse_time_offsets.size();
size_t num_samples_per_pulse_with_padding = nSamples_tx_pulse + 2*spb;
DEBUG_PRINT("spb %d, pulse length %d samples, pulse with padding %d\n", spb, nSamples_tx_pulse, num_samples_per_pulse_with_padding);
// TODO unpack and pad tx sample
for (iSide = 0; iSide<nSides; iSide++) {
tx_samples[iSide].resize(number_of_pulses * (num_samples_per_pulse_with_padding));
for(uint32_t p_i = 0; p_i < number_of_pulses; p_i++) {
shm_pulseaddr = &((std::complex<int16_t> *) shm_tx_vec[iSide][swing])[p_i*nSamples_tx_pulse];
memcpy(&tx_samples[iSide][spb + p_i*(num_samples_per_pulse_with_padding)], shm_pulseaddr, pulse_bytes);
}
}
if(SAVE_RAW_SAMPLES_DEBUG) {
FILE *raw_dump_fp;
char raw_dump_name[80];
// DEBUG_PRINT("Exporting %i raw tx_samples (%i + 2* %i)\n", num_samples_per_pulse_with_padding, nSamples_tx_pulse, spb);
for (iSide =0; iSide < nSides; iSide++){
sprintf(raw_dump_name,"%s/raw_samples_tx_ant_%d.cint16", diag_dir, antennaVector[iSide]);
raw_dump_fp = fopen(raw_dump_name, "wb");
fwrite(&tx_samples[iSide][0], sizeof(std::complex<int16_t>),num_samples_per_pulse_with_padding*number_of_pulses, raw_dump_fp);
fclose(raw_dump_fp);
}
}
state_vec[swing] = ST_READY;
DEBUG_PRINT("changing state_vec[swing] to ST_READY\n");
sock_send_uint8(driverconn, USRP_SETUP);
break;
}
case RXFE_SET: {
DEBUG_PRINT("entering RXFE_SET command\n");
RXFESettings rf_settings;
rf_settings.amp1 = sock_get_uint8(driverconn);
rf_settings.amp2 = sock_get_uint8(driverconn);
uint8_t attTimes2 = sock_get_uint8(driverconn);
rf_settings.att_05_dB = ( attTimes2 & 0x01 ) != 0;
rf_settings.att_1_dB = ( attTimes2 & 0x02 ) != 0;
rf_settings.att_2_dB = ( attTimes2 & 0x04 ) != 0;
rf_settings.att_4_dB = ( attTimes2 & 0x08 ) != 0;
rf_settings.att_8_dB = ( attTimes2 & 0x10 ) != 0;
rf_settings.att_16_dB = ( attTimes2 & 0x20 ) != 0;
kodiak_set_rxfe(usrp, rf_settings, nSides);
sock_send_uint8(driverconn, RXFE_SET);
break;
}
case TRIGGER_PULSE: {
swing = sock_get_int16( driverconn);
DEBUG_PRINT("entering TRIGGER_PULSE command (swing %d)\n", swing );
if (state_vec[swing] != ST_READY) {
sock_send_uint8(driverconn, TRIGGER_BUSY);
DEBUG_PRINT("TRIGGER_PULSE busy in state_vec[swing] %d, returning\n", state_vec[swing]);
}
else {
DEBUG_PRINT("TRIGGER_PULSE ready\n");
state_vec[swing] = ST_PULSE;
DEBUG_PRINT("TRIGGER_PULSE locking semaphore\n");
lock_semaphore(sem_rx_vec[swing]);
lock_semaphore(sem_tx_vec[swing]);
DEBUG_PRINT("TRIGGER_PULSE semaphore locked\n");
// create local copy of transmit pulse data from shared memory
size_t spb = tx_stream->get_max_num_samps();
size_t pulse_bytes = sizeof(std::complex<int16_t>) * nSamples_tx_pulse;
size_t number_of_pulses = pulse_time_offsets.size();
size_t num_samples_per_pulse_with_padding = nSamples_tx_pulse + 2*spb;
DEBUG_PRINT("spb %d, pulse length %d samples, pulse with padding %d\n", spb, nSamples_tx_pulse, num_samples_per_pulse_with_padding);
// read in time for start of pulse sequence over socket
uint32_t pulse_time_full = sock_get_uint32(driverconn);
double pulse_time_frac = sock_get_float64(driverconn);
start_time = uhd::time_spec_t(pulse_time_full, pulse_time_frac);
double tr_to_pulse_delay = sock_get_float64(driverconn);
// calculate usrp clock time of the start of each pulse over the integration period
// so we can schedule the io (perhaps we will have to move io off of the usrp if it can't keep up)
for(uint32_t p_i = 0; p_i < number_of_pulses; p_i++) {
double offset_time = pulse_sample_idx_offsets[p_i] / txrate;
pulse_time_offsets[p_i] = offset_time_spec(start_time, offset_time);
// DEBUG_PRINT("TRIGGER_PULSE pulse time %d is %2.5f\n", p_i, pulse_time_offsets[p_i].get_real_secs());
}
DEBUG_PRINT("first TRIGGER_PULSE time is %2.5f and last is %2.5f\n", pulse_time_offsets[0].get_real_secs(), pulse_time_offsets.back().get_real_secs());
rx_start_time = offset_time_spec(start_time, tr_to_pulse_delay/1e6);
rx_start_time = offset_time_spec(rx_start_time, pulse_sample_idx_offsets[0]/txrate);
// send_timing_for_sequence(usrp, start_time, pulse_times);
double pulseLength = nSamples_tx_pulse / txrate;
// float debugt = usrp->get_time_now().get_real_secs();
// DEBUG_PRINT("USRP_DRIVER: spawning worker threads at usrp_time %2.4f\n", debugt);
DEBUG_PRINT("TRIGGER_PULSE creating rx and tx worker threads on swing %d (nSamples_rx= %d + %d pause + %d auto clear freq )\n", swing,(int) nSamples_rx, nSamples_pause_after_rx, nSamples_auto_clear_freq);
// works fine with tx_worker and dio_worker, fails if rx_worker is enabled
uhd_threads.create_thread(boost::bind(usrp_rx_worker, usrp, rx_stream, &rx_data_buffer, nSamples_rx_total, rx_start_time, &rx_worker_status));
useconds_t usecs=1000;
if (tx_worker_active) {
usleep(usecs);
uhd_threads.create_thread(boost::bind(usrp_tx_worker, tx_stream, &tx_samples, num_samples_per_pulse_with_padding, start_time, pulse_sample_idx_offsets));
}
usleep(usecs);
uhd_threads.create_thread(boost::bind(send_timing_for_sequence, usrp, start_time, pulse_time_offsets, pulseLength, mimic_active, mimic_delay, nSides));
sock_send_uint8(driverconn, TRIGGER_PULSE);
uhd_threads.join_all(); // wait for transmit threads to finish, drawn from shared memory..
DEBUG_PRINT("TRIGGER_PULSE rx_worker, tx_worker and dio threads on swing %d\n joined.", swing);
}
break;
}
case READY_DATA: {
swing = sock_get_int16( driverconn);
DEBUG_PRINT("READY_DATA command (swing %d), waiting for uhd threads to join back\n", swing);
DEBUG_PRINT("READY_DATA unlocking swing a semaphore\n");
unlock_semaphore(sem_rx_vec[swing]);
unlock_semaphore(sem_tx_vec[swing]);
DEBUG_PRINT("READY_DATA usrp worker threads joined, semaphore unlocked, sending metadata\n");
// TODO: handle multiple channels of data.., use channel index to pick correct swath of memory to copy into shm
// rx_worker_status =1; //DEBUG
if(rx_worker_status){
fprintf(stderr, "Error in rx_worker. Setting state to %d.\n", rx_worker_status);
state_vec[swing] = rx_worker_status;
rx_worker_status = 0;
mute_output = 1;
rx_stream_error_count++;
if (rx_stream_reset_count >= MAX_STREAM_RESETS) {
fprintf(stderr, "READY_DATA: shutting down usrp_driver to avoid streamer reset overflow (after %dth reset)\n", rx_stream_reset_count);
// send all data to server, clean up and exit after that
exit_driver = 1;
}
if((rx_worker_status != RX_WORKER_STREAM_TIME_ERROR) && (rx_stream_error_count > 4)) {
// recreate rx_stream unless the error was from sending the stream command too late
rx_stream_reset_count++;
fprintf(stderr, "READY_DATA: recreating rx_stream %dth time! (buffer overflow will occur for 126th time)\n", rx_stream_reset_count);
rx_stream.reset();
rx_stream = usrp->get_rx_stream(stream_args);
}
auto_clear_freq_available = 0;
}
else {
rx_stream_error_count = 0;
auto_clear_freq_available = 1;
}
DEBUG_PRINT("READY_DATA state: %d, ant: %d, num_samples: %zu\n", state_vec[swing], antennaVector[0], nSamples_rx);
sock_send_int32(driverconn, state_vec[swing]); // send status
sock_send_int32(driverconn, antennaVector[0]); // send antenna TODO do this for both antennas?
sock_send_int32(driverconn, nSamples_rx); // nsamples; send send number of samples
// read FAULT status
bool fault;
for (iSide =0; iSide<nSides; iSide++){
fault = read_FAULT_status_from_control_board(usrp, iSide);
}
// TODO move this in loop as soon as usrp_server receives both sides
sock_send_bool(driverconn, fault); // FAULT status from conrol board
if (mute_output) {
DEBUG_PRINT("READY_DATA: Filling SHM with zeros (because of rx_worker error) \n");
for (iSide = 0; iSide<nSides; iSide++) {
memset(shm_rx_vec[iSide][swing], 0, rxshm_size);
std::fill(rx_auto_clear_freq[iSide].begin(), rx_auto_clear_freq[iSide].end(), 0);
}
mute_output = 0;
}
else {
DEBUG_PRINT("READY_DATA starting copying rx data buffer to shared memory\n");
// regural rx data
for (iSide = 0; iSide<nSides; iSide++) {
// DEBUG_PRINT("usrp_drivercopy to rx shm addr: %p iSide: %d iSwing: %d\n", shm_rx_vec[iSide][swing], iSide, iSwing);
memcpy(shm_rx_vec[iSide][swing], &rx_data_buffer[iSide][0], sizeof(std::complex<int16_t>) * nSamples_rx);
}
// auto clear freq samples
for (iSide = 0; iSide<nSides; iSide++) {
for (int iSample = 0; iSample < nSamples_auto_clear_freq; iSample++) {
rx_auto_clear_freq[iSide][iSample] = rx_data_buffer[iSide][nSamples_rx+nSamples_pause_after_rx+ iSample];
}
}
}
if(SAVE_RAW_SAMPLES_DEBUG) {
FILE *raw_dump_fp;
char raw_dump_name[80];
for (iSide=0; iSide<nSides; iSide++) {
sprintf(raw_dump_name,"%s/raw_samples_rx_ant_%d.cint16", diag_dir, antennaVector[iSide]);
raw_dump_fp = fopen(raw_dump_name, "wb");
fwrite(&rx_data_buffer[iSide], sizeof(std::complex<int16_t>), nSamples_rx_total, raw_dump_fp);
fclose(raw_dump_fp);
}
}
DEBUG_PRINT("READY_DATA finished copying rx data buffer to shared memory\n");
state_vec[swing] = ST_READY;
DEBUG_PRINT("changing state_vec[swing] to ST_READY\n");
DEBUG_PRINT("READY_DATA returning command success \n");
sock_send_uint8(driverconn, READY_DATA);
break;
}
case UHD_GETTIME: {
DEBUG_PRINT("entering UHD_GETTIME command\n");
start_time = usrp->get_time_now();
uint32_t real_time = start_time.get_real_secs();
double frac_time = start_time.get_frac_secs();
sock_send_uint32(driverconn, real_time);
sock_send_float64(driverconn, frac_time);
DEBUG_PRINT("UHD_GETTIME current UHD time: %d %.2f command\n", real_time, frac_time);
sock_send_uint8(driverconn, UHD_GETTIME);
break;
}
// command to reset time, sync time with external PPS pulse
case UHD_SYNC: {
DEBUG_PRINT("entering UHD_SYNC command\n");
// if --intclk flag passed to usrp_driver, set clock source as internal and do not sync time
if(al_intclk->count > 0) {
usrp->set_time_now(uhd::time_spec_t(0.0));
}
else {
/* const uhd::time_spec_t last_pps_time = usrp->get_time_last_pps();
while (last_pps_time == usrp->get_time_last_pps()) {
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
}
usrp->set_time_next_pps(uhd::time_spec_t(0.0));
boost::this_thread::sleep(boost::posix_time::milliseconds(1100));
*/
DEBUG_PRINT("Start setting unknown pps\n");
usrp->set_time_unknown_pps(uhd::time_spec_t(11.0));
DEBUG_PRINT("end setting unknown pps\n");
}
sock_send_uint8(driverconn, UHD_SYNC);
break;
}
case AUTOCLRFREQ: {
// has to be called after GET_DATA and before USRP_SETUP
DEBUG_PRINT("entering getting auto clear freq command\n");
// uint32_t num_clrfreq_samples = sock_get_uint32(driverconn);
iSide = 0;// TODO both sides!
if (auto_clear_freq_available) {
DEBUG_PRINT("AUTOCLRFREQ samples sending %d samples for antenna %d...\n", rx_auto_clear_freq[iSide].size(),antennaVector[iSide]);
sock_send_int32(driverconn, (int32_t) antennaVector[iSide]);
sock_send_uint32(driverconn, (uint32_t) rx_auto_clear_freq[iSide].size());
// send samples
send(driverconn, &rx_auto_clear_freq[iSide][0], sizeof(std::complex<short int>) * rx_auto_clear_freq[iSide].size() , 0);
}
else {
sock_send_int32(driverconn, (int32_t) -1);
}
sock_send_uint8(driverconn, AUTOCLRFREQ);
break;
}
case CLRFREQ: {
DEBUG_PRINT("entering CLRFREQ command\n");
uint32_t num_clrfreq_samples = sock_get_uint32(driverconn);
uint32_t clrfreq_time_full = sock_get_uint32(driverconn);
double clrfreq_time_frac = sock_get_float64(driverconn);
double clrfreq_cfreq = sock_get_float64(driverconn);
double clrfreq_rate = sock_get_float64(driverconn);
std::vector<std::vector<std::complex<int16_t>>> clrfreq_data_buffer(nSides, std::vector<std::complex<int16_t>>(num_clrfreq_samples));
uint32_t real_time;
double frac_time;
DEBUG_PRINT("CLRFREQ time: %d . %.2f \n", clrfreq_time_full, clrfreq_time_frac);
DEBUG_PRINT("CLRFREQ rate: %.2f, CLRFREQ_nsamples %d, freq: %.2f\n", clrfreq_rate, num_clrfreq_samples, clrfreq_cfreq);
uhd::time_spec_t clrfreq_start_time = uhd::time_spec_t(clrfreq_time_full, clrfreq_time_frac);
real_time = clrfreq_start_time.get_real_secs();
frac_time = clrfreq_start_time.get_frac_secs();
DEBUG_PRINT("CLRFREQ UHD clrfreq target time: %d %.2f \n", real_time, frac_time);
// TODO: only set rate if it is different!
if(rxrate != clrfreq_rate) {
usrp->set_rx_rate(clrfreq_rate);
rxrate = usrp->get_rx_rate();
clrfreq_rate = rxrate;
}
DEBUG_PRINT("CLRFREQ actual rate: %.2f\n", clrfreq_rate);
//clrfreq_cfreq = usrp->get_rx_freq();
//DEBUG_PRINT("CLRFREQ actual freq: %.2f\n", clrfreq_cfreq);
clrfreq_threads.create_thread(boost::bind(usrp_rx_worker, usrp, rx_stream, &clrfreq_data_buffer, num_clrfreq_samples, clrfreq_start_time, &clrfreq_rx_worker_status));
clrfreq_threads.join_all();
if(clrfreq_rx_worker_status){
fprintf(stderr, "Error in clrfreq_rx_worker, resetting rx_stream: %d.\n", clrfreq_rx_worker_status);
rx_stream_reset_count++;
fprintf(stderr, "CLRFREQ: recreating rx_stream %dth time! (buffer overflow will occur for 126th time)\n", rx_stream_reset_count);
rx_stream.reset();
rx_stream = usrp->get_rx_stream(stream_args);
}
if (rx_stream_reset_count >= MAX_STREAM_RESETS) {
fprintf(stderr, "CLRFREQ: shutting down usrp_driver to avoid streamer reset overflow (after %dth reset)\n", rx_stream_reset_count);
// finish clrfreq command, then clean up and exit to avoid buffer overflow
exit_driver = 1;
}
DEBUG_PRINT("CLRFREQ received samples, relaying %d samples back...\n", num_clrfreq_samples);
sock_send_int32(driverconn, (int32_t) antennaVector[0]); // TODO both sides?
sock_send_float64(driverconn, clrfreq_rate);
// send back samples
send(driverconn, &clrfreq_data_buffer[0][0], sizeof(std::complex<short int>) * num_clrfreq_samples, 0);
//for(uint32_t i = 0; i < num_clrfreq_samples; i++) {
//DEBUG_PRINT("sending %d - %d\n", i, clrfreq_data_buffer[0][i]);
// sock_send_cshort(driverconn, clrfreq_data_buffer[0][i]);
// }
DEBUG_PRINT("CLRFREQ samples sent for antenna %d...\n", antennaVector[0]);
// restore usrp rates
usrp->set_rx_rate(rxrate);
usrp->set_rx_freq(rxfreq);
sock_send_uint8(driverconn, CLRFREQ);
start_time = usrp->get_time_now();
real_time = start_time.get_real_secs();
frac_time = start_time.get_frac_secs();
DEBUG_PRINT("CLRFREQ finished at UHD time: %d %.2f \n", real_time, frac_time);
break;
}
case EXIT: {
DEBUG_PRINT("entering EXIT command\n");
exit_driver = 1;
break;
}
default: {
printf("USRP_DRIVER unrecognized command: %d, %c, exiting..\n", command, command);
sleep(10);
exit(1);
break;
}
}
if (not check_clock_lock(usrp)) {
fprintf(stderr, "Error: Lost clock for USRP: %s\n ", as_host->sval[0]);
exit_driver = 1;
}
// clean exit
if (exit_driver) {
DEBUG_PRINT("Shutting down driver\n");
close(driverconn);
for(iSide = 0; iSide < nSides; iSide++) {
for(iSwing = 0; iSwing < nSwings; iSwing++) {
// fill SHM with zeros
memset(shm_rx_vec[iSide][iSwing], 0, rxshm_size);
memset(shm_tx_vec[iSide][iSwing], 0, txshm_size);
munmap(shm_rx_vec[iSide][iSwing], rxshm_size);
munmap(shm_tx_vec[iSide][iSwing], txshm_size);
sem_close(&sem_rx_vec[iSwing]);
sem_close(&sem_tx_vec[iSwing]);
}
}
// TODO: close usrp streams?
// sock_send_uint8(driverconn, EXIT);
exit(1);
}
}
}
return 0;
}
int main(int argc, char **argv)
{
// parameter structures
struct arg_lit *param_stop = arg_lit0("p", "stop", "stop animation");
struct arg_lit *param_single = arg_lit0("s", "single", "single animation");
struct arg_lit *param_loop = arg_lit0("l", "loop", "loop animation");
struct arg_int *param_frame = arg_int0("f", "frame", "<n>", "frame data");
struct arg_int *param_pos = arg_int0("p", "pos", "<n>", "frame pos in eeprom");
struct arg_int *param_delay = arg_int0("d", "delay", "<n>", "frame delay in eeprom");
struct arg_lit *param_save = arg_lit0("v", "save", "save one frame to the EEPROM (position, delay and frame required)");
//struct arg_lit *param_tty = arg_lit0("t", "terminal", "terminal mode");
//struct arg_lit *param_daemon = arg_lit0("d", "daemon", "daemon mode");
struct arg_lit *param_help = arg_lit0("h", "help", "show help");
struct arg_file *param_file = arg_filen("i", "ihex-file","<file>", 0, 1, "iHex input file to write to the EEPROM");
struct arg_end *param_end = arg_end(20);
// default parameter
param_frame->ival[0] = 0x00000000;
param_pos->ival[0] = 0;
param_delay->ival[0] = 1;
// argtable array
void *argtable[] = {
param_stop,
param_single,
param_loop,
param_frame,
param_pos,
param_delay,
param_save,
param_file,
//param_tty,
//param_daemon,
param_help,
param_end
};
// parse the commandline arguments
int nerrors = arg_parse(argc,argv,argtable);
if (arg_nullcheck(argtable) != 0)
{
printf("error: insufficient memory\n");
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return 0;
}
if (nerrors == 0 && param_help->count > 0)
{
printf("usage: ./clcc <OPTIONS>\n");
arg_print_glossary(stdout, argtable, "\t%-25s %s\n");
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return 0;
}
// parsing failed or to less parameter given
if (nerrors > 0
|| argc < 2
|| (param_save->count > 0 && (param_pos->count == 0 || param_delay->count == 0 || param_frame->count == 0))
)
{
arg_print_errors(stdout,param_end,"clcc");
printf("usage: ./clcc <OPTIONS>\n");
arg_print_syntaxv(stdout,argtable,"\n");
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return -1;
}
if (lc_init() != SUCCESSFULLY_CONNECTED)
{
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
lc_close();
return -2;
}
if (param_stop->count > 0)
{
printf("stop animation loop\n");
lc_setMode(MODE_ANIMATION_STOP);
}
else if (param_loop->count > 0)
{
printf("starting animation loop\n");
lc_setMode(MODE_ANIMATION_LOOP);
}
else if (param_single->count > 0 )
{
printf("starting animation as single shot\n");
lc_setMode(MODE_ANIMATION_SINGLE);
}
else if (param_save->count > 0
&& param_pos->count > 0
&& param_delay->count > 0
&& param_frame->count > 0)
{
lc_setMode(MODE_ANIMATION_STOP);
int frame = param_frame->ival[0];
int delay = param_delay->ival[0];
int pos = param_pos->ival[0];
printf("saving frame: index=%d delay=%d frame=0x%08x\n", pos, delay, frame);
lc_saveFrame(frame, delay, pos);
}
else if (param_frame->count > 0)
{
lc_setMode(MODE_ANIMATION_STOP);
int frame = param_frame->ival[0];
printf("view frame: data=0x%08x\n", frame);
lc_setFrame(frame);
}
//printf("file[%d]=%s\n",i,file->filename[i]);*/
lc_close();
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return 0;
}
int main(int argc, char** argv) {
struct arg_int *numVerticesArg = arg_int0("v","vertices",NULL, "num vertices (default is 20)");
struct arg_int *numObjectsArg = arg_int0("o","objects",NULL, "num objects (default is 20)");
struct arg_lit *help = arg_lit0(NULL,"help", "print this help and exit");
struct arg_str *rendererArg = arg_str1(NULL,NULL,"RENDERER",NULL);
struct arg_end *end = arg_end(20);
void* argtable[] = {numVerticesArg, numObjectsArg, help, rendererArg, end};
const char* progname = "gl-instancing";
int exitcode=0;
int nerrors;
renderer *renderer;
int numVertices = 20;
int numObjects = 20;
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0)
{
/* NULL entries were detected, some allocations must have failed */
printf("%s: insufficient memory\n",progname);
exitcode=1;
goto exit;
}
/* Parse the command line as defined by argtable[] */
nerrors = arg_parse(argc,argv,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printUsage(stderr, progname, argtable);
goto exit;
}
if (numVerticesArg->count > 0) {
numVertices = numVerticesArg->ival[0];
}
if (numObjectsArg->count > 0) {
numObjects = numObjectsArg->ival[0];
}
if (rendererArg->count == 0) {
fprintf(stderr, "Provide a renderer!\n");
printUsage(stderr, progname, argtable);
goto exit;
}
if (rendererArg->count > 0) {
if (strcmp(rendererArg->sval[0], "standard") == 0) {
renderer = getStandardRenderer(numVertices, numObjects);
} else if (strcmp(rendererArg->sval[0], "instanced") == 0) {
renderer = getInstancedRenderer(numVertices, numObjects);
} else {
fprintf(stderr, "Renderer %s is unknown. Supported renderers: instanced, standard\n", rendererArg->sval[0]);
printUsage(stderr, progname, argtable);
goto exit;
}
}
exitcode = glMain(renderer);
exit:
/* deallocate each non-null entry in argtable[] */
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return exitcode;
}
int main(int argc, char* argv[]) {
double discountFactor;
unsigned int maxNbEvaluations;
char isTerminal = 0;
char keepingTree = 0;
int nbTimestep = -1;
unsigned int branchingFactor = 0;
#ifdef USE_SDL
char isDisplayed = 1;
char isFullscreen = 1;
char verbose = 0;
char resolution[255] = "640x480";
#else
char verbose = 1;
#endif
uniform_instance* instance = NULL;
state* crtState = NULL;
state* nextState = NULL;
double reward = 0.0;
action* optimalAction = NULL;
struct arg_dbl* g = arg_dbl1("g", "discountFactor", "<d>", "The discount factor for the problem");
struct arg_int* n = arg_int1("n", "nbEvaluations", "<n>", "The number of evaluations");
struct arg_int* s = arg_int0("s", "nbtimestep", "<n>", "The number of timestep");
struct arg_int* b = arg_int0("b", "branchingFactor", "<n>", "The branching factor of the problem");
struct arg_lit* k = arg_lit0("k", NULL, "Keep the subtree");
struct arg_str* i = arg_str0(NULL, "state", "<s>", "The initial state to use");
#ifdef USE_SDL
struct arg_lit* d = arg_lit0("d", NULL, "Display the viewer");
struct arg_lit* f = arg_lit0("f", NULL, "Fullscreen");
struct arg_lit* v = arg_lit0("v", NULL, "Verbose");
struct arg_str* r = arg_str0(NULL, "resolution", "<s>", "The resolution of the display window");
void* argtable[11];
int nbArgs = 10;
#else
void* argtable[7];
int nbArgs = 6;
#endif
struct arg_end* end = arg_end(nbArgs+1);
int nerrors = 0;
s->ival[0] = -1;
b->ival[0] = 0;
argtable[0] = g; argtable[1] = n; argtable[2] = s; argtable[3] = k; argtable[4] = b; argtable[5] = i;
#ifdef USE_SDL
argtable[6] = d;
argtable[7] = f;
argtable[8] = v;
argtable[9] = r;
#endif
argtable[nbArgs] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, nbArgs+1);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, nbArgs+1);
return EXIT_FAILURE;
}
discountFactor = g->dval[0];
maxNbEvaluations = n->ival[0];
branchingFactor = b->ival[0];
initGenerativeModelParameters();
if(branchingFactor)
K = branchingFactor;
initGenerativeModel();
if(i->count)
crtState = makeState(i->sval[0]);
else
crtState = initState();
#if USE_SDL
isDisplayed = d->count;
isFullscreen = f->count;
verbose = v->count;
if(r->count)
strcpy(resolution, r->sval[0]);
#endif
nbTimestep = s->ival[0];
keepingTree = k->count;
arg_freetable(argtable, nbArgs+1);
instance = uniform_initInstance(crtState, discountFactor);
#ifdef USE_SDL
if(isDisplayed) {
if(initViewer(resolution, uniform_drawingProcedure, isFullscreen) == -1)
return EXIT_FAILURE;
viewer(crtState, NULL, 0.0, instance);
}
#endif
do {
if(keepingTree)
uniform_keepSubtree(instance);
else
uniform_resetInstance(instance, crtState);
optimalAction = uniform_planning(instance, maxNbEvaluations);
isTerminal = nextStateReward(crtState, optimalAction, &nextState, &reward);
freeState(crtState);
crtState = nextState;
if(verbose) {
printState(crtState);
printAction(optimalAction);
printf("reward: %f depth: %u\n", reward, uniform_getMaxDepth(instance));
}
#ifdef USE_SDL
} while(!isTerminal && (nbTimestep < 0 || --nbTimestep) && !viewer(crtState, optimalAction, reward, instance));
#else
} while(!isTerminal && (nbTimestep < 0 || --nbTimestep));
int main(int argc, char *argv[]) {
// commandline argument parser options
struct arg_lit *help = arg_lit0("h", "help", "print this help and exit");
struct arg_lit *vers = arg_lit0("v", "version", "print version information and exit");
struct arg_file *file = arg_file1("f", "file", "<file>", "Score file");
struct arg_int *page = arg_int0("p", "page", "<int>", "Page ID");
struct arg_file *output = arg_file0("o", "output", "<file>", "Output file");
struct arg_end *end = arg_end(20);
void* argtable[] = {help,vers,file,page,output,end};
const char* progname = "scoretool";
// Make sure everything got allocated
if(arg_nullcheck(argtable) != 0) {
printf("%s: insufficient memory\n", progname);
goto exit_0;
}
// Parse arguments
int nerrors = arg_parse(argc, argv, argtable);
// Handle help
if(help->count > 0) {
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
printf("\nArguments:\n");
arg_print_glossary(stdout, argtable, "%-25s %s\n");
goto exit_0;
}
// Handle version
if(vers->count > 0) {
printf("%s v0.1\n", progname);
printf("Command line One Must Fall 2097 Score file editor.\n");
printf("Source code is available at https://github.com/omf2097 under MIT license.\n");
printf("(C) 2014 Tuomas Virtanen\n");
goto exit_0;
}
// Handle errors
if(nerrors > 0) {
arg_print_errors(stdout, end, progname);
printf("Try '%s --help' for more information.\n", progname);
goto exit_0;
}
// Get score information
sd_score score;
sd_score_create(&score);
int ret = sd_score_load(&score, file->filename[0]);
if(ret != SD_SUCCESS) {
printf("Score file %s could not be loaded: %s\n",
file->filename[0],
sd_get_error(ret));
goto exit_0;
}
// See if we want to print a single page or all pages
if(page->count > 0) {
int page_id = page->ival[0];
if(page_id < 0 || page_id >= SD_SCORE_PAGES) {
printf("Page must be between 0 and 3.\n");
goto exit_1;
}
// Print only this page
print_page(&score, page_id);
} else {
for(int i = 0; i < SD_SCORE_PAGES; i++) {
print_page(&score, i);
printf("\n");
}
}
// Save if necessary
if(output->count > 0) {
ret = sd_score_save(&score, output->filename[0]);
if(ret != SD_SUCCESS) {
printf("Failed to save scores file to %s: %s\n",
output->filename[0],
sd_get_error(ret));
}
}
exit_1:
sd_score_free(&score);
exit_0:
arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0]));
return 0;
}
int _tmain(int argc, char* argv[])
{
// determine my process name
_splitpath(argv[0],NULL,NULL,gszProcName,NULL);
#else
int
main(int argc, const char** argv)
{
// determine my process name
CUtility::splitpath((char *)argv[0],NULL,gszProcName);
#endif
int iScreenLogLevel; // level of screen diagnostics
int iFileLogLevel; // level of file diagnostics
char szLogFile[_MAX_PATH]; // write diagnostics to this file
int Rslt;
int iProcMode;
int iMinLength;
int iMaxLength;
int iMinMergeLength;
int iMaxMergeLength;
char szRefFile[_MAX_PATH]; // process ref hypers from this file
char szRelFile[_MAX_PATH]; // process rel hypers from this file
char szOutLociFile[_MAX_PATH]; // write loci to this file
char szRefSpecies[cMaxDatasetSpeciesChrom]; // use this species as the ref species in generated szOutLociFile
char szRelSpecies[cMaxDatasetSpeciesChrom]; // use this species/list as the rel species in generated szOutLociFile
char szElType[cMaxDatasetSpeciesChrom]; // use this as the element type in generated szOutLociFile
int iRefExtend; // extend ref element lengths left+right by this many bases
int iRelExtend; // extend rel element lengths left+right by this many bases
int iJoinDistance; // if > 0 then join elements which only differ by at most this distance beween end of element i and start of element i+1
// command line args
struct arg_lit *help = arg_lit0("h","help", "print this help and exit");
struct arg_lit *version = arg_lit0("v","version,ver", "print version information and exit");
struct arg_int *FileLogLevel=arg_int0("f", "FileLogLevel", "<int>","Level of diagnostics written to screen and logfile 0=fatal,1=errors,2=info,3=diagnostics,4=debug");
struct arg_file *LogFile = arg_file0("F","log","<file>", "diagnostics log file");
struct arg_file *RefFile = arg_file1("i","reffile","<file>", "reference hyper element CSV file");
struct arg_file *RelFile = arg_file0("I","relfile","<file>", "relative hyper element CSV file");
struct arg_file *OutLociFile = arg_file1("o",NULL,"<file>", "output loci to file as CSV");
struct arg_str *RefSpecies = arg_str1("r","refspecies","<string>","output loci file ref species");
struct arg_str *RelSpecies = arg_str1("R","relspecies","<string>","output loci file rel species");
struct arg_str *ElType = arg_str0("t","eltype","<string>","output loci file element type");
struct arg_int *ProcMode = arg_int0("p","mode","<int>", "processing mode: 0:Intersect (Ref & Rel)\n\t\t1:Ref exclusive (Ref & !Rel)\n\t\t2:Rel exclusive (!Ref & Rel)\n\t\t3:Union (Ref | Rel)\n\t\t4:Neither (!(Ref | Rel))");
struct arg_int *MinLength = arg_int0("l","minlength","<int>", "minimum input ref/rel element length (default 4)");
struct arg_int *MaxLength = arg_int0("L","maxlength","<int>", "maximum input ref/rel element length (default 1000000)");
struct arg_int *MinMergeLength = arg_int0("m","minmergelength","<int>","minimum merged output element length (default 4)");
struct arg_int *MaxMergeLength = arg_int0("M","maxmergelength","<int>","maximum merged output element length (default 1000000)");
struct arg_int *RefExtend = arg_int0("e","refextend","<int>", "extend ref element flanks left+right by this many bases (default 0)");
struct arg_int *RelExtend = arg_int0("E","relextend","<int>", "extend rel element flanks left+right by this many bases (default 0)");
struct arg_int *JoinDistance = arg_int0("j","join","<int>", "merge output elements which are only separated by this number of bases (default 0)");
struct arg_end *end = arg_end(20);
void *argtable[] = {help,version,FileLogLevel,LogFile,
ProcMode,
RefFile,RelFile,OutLociFile,
MinLength,MaxLength,RefExtend,RelExtend,JoinDistance,MinMergeLength,MaxMergeLength,
RefSpecies,RelSpecies,ElType,
end};
char **pAllArgs;
int argerrors;
argerrors = CUtility::arg_parsefromfile(argc,(char **)argv,&pAllArgs);
if(argerrors >= 0)
argerrors = arg_parse(argerrors,pAllArgs,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("\n%s CSV Merge Elements, Version %s\nOptions ---\n", gszProcName,cpszProgVer);
arg_print_syntax(stdout,argtable,"\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
printf("\nNote: Parameters can be entered into a parameter file, one parameter per line.");
printf("\n To invoke this parameter file then precede its name with '@'");
printf("\n e.g. %s @myparams.txt\n",gszProcName);
printf("\nPlease report any issues regarding usage of %s at https://github.com/csiro-crop-informatics/biokanga/issues\n\n",gszProcName);
exit(1);
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0)
{
printf("\n%s Version %s\n",gszProcName,cpszProgVer);
exit(1);
}
if (!argerrors)
{
if(FileLogLevel->count && !LogFile->count)
{
printf("\nError: FileLogLevel '-f%d' specified but no logfile '-F<logfile>'",FileLogLevel->ival[0]);
exit(1);
}
iScreenLogLevel = iFileLogLevel = FileLogLevel->count ? FileLogLevel->ival[0] : eDLInfo;
if(iFileLogLevel < eDLNone || iFileLogLevel > eDLDebug)
{
printf("\nError: FileLogLevel '-l%d' specified outside of range %d..%d",iFileLogLevel,eDLNone,eDLDebug);
exit(1);
}
if(LogFile->count)
{
strncpy(szLogFile,LogFile->filename[0],_MAX_PATH);
szLogFile[_MAX_PATH-1] = '\0';
}
else
{
iFileLogLevel = eDLNone;
szLogFile[0] = '\0';
}
iProcMode = ProcMode->count ? ProcMode->ival[0] : ePMElIntersect;
if(iProcMode < ePMElIntersect || iProcMode > ePMElRefNotRefRel)
{
printf("Error: Processing mode '-p%d' is not in range 0..4",iProcMode);
exit(1);
}
strncpy(szOutLociFile,OutLociFile->filename[0],_MAX_PATH);
szOutLociFile[_MAX_PATH-1] = '\0';
strncpy(szRefSpecies,RefSpecies->sval[0],sizeof(szRefSpecies));
szRefSpecies[sizeof(szRefSpecies)-1] = '\0';
strncpy(szRelSpecies,RelSpecies->sval[0],sizeof(szRelSpecies));
szRelSpecies[sizeof(szRelSpecies)-1] = '\0';
if(ElType->count)
{
strncpy(szElType,ElType->sval[0],sizeof(szElType));
szElType[sizeof(szElType)-1] = '\0';
}
else
strcpy(szElType,"merged");
iMinLength = MinLength->count ? MinLength->ival[0] : cDfltMinLength;
if(iMinLength < 0 || iMinLength > cMaxLengthRange)
{
printf("Error: Minimum element length '-l%d' is not in range 0..%d",iMinLength,cMaxLengthRange);
exit(1);
}
iMaxLength = MaxLength->count ? MaxLength->ival[0] : cDfltMaxLength;
if(iMaxLength < iMinLength || iMaxLength > cMaxLengthRange)
{
printf("Error: Maximum element length '-L%d' is not in range %d..%d",iMaxLength,iMinLength,cMaxLengthRange);
exit(1);
}
iMinMergeLength = MinMergeLength->count ? MinMergeLength->ival[0] : cDfltMinLength;
if(iMinMergeLength < 0 || iMinMergeLength > cMaxLengthRange)
{
printf("Error: Minimum output merged element length '-m%d' is not in range 0..%d",iMinMergeLength,cMaxLengthRange);
exit(1);
}
iMaxMergeLength = MaxMergeLength->count ? MaxMergeLength->ival[0] : cDfltMaxLength;
if(iMaxMergeLength < iMinMergeLength || iMaxMergeLength > cMaxLengthRange)
{
printf("Error: Maximum element length '-M%d' is not in range %d..%d",iMaxMergeLength,iMinMergeLength,cMaxLengthRange);
exit(1);
}
iJoinDistance = JoinDistance->count ? JoinDistance->ival[0] : cDfltJoinOverlap;
if(iJoinDistance < 0 || iJoinDistance > cMaxJoinOverlap)
{
printf("Error: Join separation length '-j%d' is not in range %d..%d",iJoinDistance,0,cMaxJoinOverlap);
exit(1);
}
iRefExtend = RefExtend->count ? RefExtend->ival[0] : 0;
if(iRefExtend < (-1 * cMaxExtendLength) || iRefExtend > cMaxExtendLength)
{
printf("Error: Ref Extension length '-e%d' is not in range %d..%d",iRefExtend,(-1 * cMaxExtendLength),cMaxExtendLength);
exit(1);
}
iRelExtend = RelExtend->count ? RelExtend->ival[0] : 0;
if(iRelExtend < (-1 * cMaxExtendLength) || iRelExtend > cMaxExtendLength)
{
printf("Error: Rel Extension length '-E%d' is not in range %d..%d",iRelExtend,(-1 * cMaxExtendLength),cMaxExtendLength);
exit(1);
}
strncpy(szRefFile,RefFile->filename[0],_MAX_PATH);
szRefFile[_MAX_PATH-1] = '\0';
if(RelFile->count)
{
strncpy(szRelFile,RelFile->filename[0],_MAX_PATH);
szRelFile[_MAX_PATH-1] = '\0';
}
else
{
if(iProcMode == ePMElRefExclusive || iProcMode == ePMElRefRelUnion)
szRelFile[0] = '\0';
else
{
printf("Error: Rel loci file must be specified in processing mode '-p%d' (%s)",iProcMode,ProcMode2Txt((etProcMode)iProcMode));
exit(1);
}
}
// now that command parameters have been parsed then initialise diagnostics log system
if(!gDiagnostics.Open(szLogFile,(etDiagLevel)iScreenLogLevel,(etDiagLevel)iFileLogLevel,true))
{
printf("\nError: Unable to start diagnostics subsystem.");
if(szLogFile[0] != '\0')
printf(" Most likely cause is that logfile '%s' can't be opened/created",szLogFile);
exit(1);
}
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Version: %s Processing parameters:",cpszProgVer);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Processing Mode: %d (%s)",iProcMode,ProcMode2Txt((etProcMode)iProcMode));
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Reference CSV file: '%s'",szRefFile);
if(szRelFile[0] != '\0')
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Relative CSV file: '%s'",szRelFile);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output processed loci into CSV file: '%s'",szOutLociFile);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output loci file ref species: '%s'",szRefSpecies);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output loci file rel species: '%s'",szRelSpecies);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Output loci file element type: '%s'",szElType);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Minimum input element length: %d",iMinLength);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Maximum input element length: %d",iMaxLength);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Ref element flank extension length: %d",iRefExtend);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Rel element flank extension length: %d",iRelExtend);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Merge output elements separated by at most this many bases: %d",iJoinDistance);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Minimum output merged element length: %d",iMinMergeLength);
gDiagnostics.DiagOutMsgOnly(eDLInfo,"Maximum output merged element length: %d",iMaxMergeLength);
// processing here...
gStopWatch.Start();
#ifdef _WIN32
SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);
#endif
Rslt = Process((etProcMode)iProcMode,iMinLength,iMaxLength,iRefExtend,iRelExtend,iJoinDistance,iMinMergeLength,iMaxMergeLength,szRefFile,szRelFile,szOutLociFile,
szRefSpecies,szRelSpecies,szElType);
gStopWatch.Stop();
Rslt = Rslt >=0 ? 0 : 1;
gDiagnostics.DiagOut(eDLInfo,gszProcName,"Exit code: %d Total processing time: %s",Rslt,gStopWatch.Read());
exit(Rslt);
}
else
{
printf("\n%s CSV Merge Elements, Version %s\n",gszProcName,cpszProgVer);
arg_print_errors(stdout,end,gszProcName);
arg_print_syntax(stdout,argtable,"\nUse '-h' to view option and parameter usage\n");
exit(1);
}
}
int main(int argc, char* argv[]) {
double discountFactor = 0.9;
FILE* initFileFd = NULL;
double* setPoints = NULL;
unsigned int nbSetPoints = 0;
unsigned int maxDepth = 0;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int minDepth = 1;
unsigned int crtDepth = 0;
unsigned int maxNbIterations = 0;
unsigned int nbSteps = 0;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
optimistic_instance* optimistic = NULL;
random_search_instance* random_search = NULL;
uct_instance* uct = NULL;
uniform_instance* uniform = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the set points");
struct arg_int* d2 = arg_int0(NULL, "min", "<n>", "Minimum depth to start from (min>0)");
struct arg_int* d = arg_int1("d", NULL, "<n>", "Maximum depth of an uniform tree which the number of call per step");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(7);
int nerrors = 0;
void* argtable[7];
argtable[0] = initFile;
argtable[1] = d2;
argtable[2] = d;
argtable[3] = s;
argtable[4] = k;
argtable[5] = where;
argtable[6] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
K = k->ival[0];
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &nbSetPoints);
setPoints = (double*)malloc(sizeof(double) * nbSetPoints);
for(; i < nbSetPoints; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
setPoints[i] = strtod(str, NULL);
}
fclose(initFileFd);
if(d2->count)
minDepth = d2->ival[0];
maxDepth = d->ival[0];
maxNbIterations = K;
nbSteps = s->ival[0];
optimistic = optimistic_initInstance(NULL, discountFactor);
random_search = random_search_initInstance(NULL, discountFactor);
uct = uct_initInstance(NULL, discountFactor);
uniform = uniform_initInstance(NULL, discountFactor);
sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps);
results = fopen(str, "w");
for(crtDepth = 1; crtDepth < minDepth; crtDepth++)
maxNbIterations += pow(K, crtDepth+1);
for(crtDepth = minDepth; crtDepth <= maxDepth; crtDepth++) {
double averages[4] = {0.0, 0.0, 0.0, 0.0};
state* crt1 = initState();
state* crt2 = copyState(crt1);
state* crt3 = copyState(crt1);
state* crt4 = copyState(crt1);
optimistic_resetInstance(optimistic, crt1);
uct_resetInstance(uct, crt3);
uniform_resetInstance(uniform, crt4);
for(i = 0; i < nbSetPoints; i++) {
unsigned int j = 0;
parameters[10] = setPoints[i];
for(; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
optimistic_keepSubtree(optimistic);
action* optimalAction = optimistic_planning(optimistic, maxNbIterations);
isTerminal = nextStateReward(crt1, optimalAction, &nextState, &reward);
freeState(crt1);
crt1 = nextState;
averages[0] += reward;
if(isTerminal < 0)
break;
}
optimistic_resetInstance(optimistic, crt1);
printf("Optimistic : %uth set point processed\n", i + 1);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
random_search_resetInstance(random_search, crt2);
action* optimalAction = random_search_planning(random_search, maxNbIterations);
isTerminal = nextStateReward(crt2, optimalAction, &nextState, &reward);
freeState(crt2);
crt2 = nextState;
averages[1] += reward;
if(isTerminal < 0)
break;
}
random_search_resetInstance(random_search, crt1);
printf("Random search: %uth set point processed\n", i + 1);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
uct_keepSubtree(uct);
action* optimalAction = uct_planning(uct, maxNbIterations);
isTerminal = nextStateReward(crt3, optimalAction, &nextState, &reward);
freeState(crt3);
crt3 = nextState;
averages[2] += reward;
if(isTerminal < 0)
break;
}
uct_resetInstance(uct, crt3);
printf("Uct : %uth set point processed\n", i + 1);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
uniform_keepSubtree(uniform);
action* optimalAction = uniform_planning(uniform, maxNbIterations);
isTerminal = nextStateReward(crt4, optimalAction, &nextState, &reward);
freeState(crt4);
crt4 = nextState;
averages[3] += reward;
if(isTerminal < 0)
break;
}
uniform_resetInstance(uniform, crt4);
printf("Uniform : %uth set point processed\n", i + 1);
printf(">>>>>>>>>>>>>> %uth set point processed\n", i + 1);
}
fprintf(results, "%u,%.15f,%.15f,%.15f,%.15f\n", maxNbIterations, averages[0] / (double)nbSetPoints, averages[1] / (double)nbSetPoints, averages[2] / (double)nbSetPoints, averages[3] / (double)nbSetPoints);
fflush(results);
freeState(crt1);
freeState(crt2);
freeState(crt3);
freeState(crt4);
printf(">>>>>>>>>>>>>> %u depth done\n\n", crtDepth);
maxNbIterations += pow(K, crtDepth+1);
}
fclose(results);
arg_freetable(argtable, 7);
free(setPoints);
optimistic_uninitInstance(&optimistic);
random_search_uninitInstance(&random_search);
uct_uninitInstance(&uct);
uniform_uninitInstance(&uniform);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
/* The argtable[] entries define the command line options */
void *argtable[] = {
a = arg_lit0("a", "all", "do not hide entries starting with ."),
A = arg_lit0("A", "almost-all", "do not list implied . and .."),
author = arg_lit0(NULL,"author", "print the author of each file"),
b = arg_lit0("b", "escape", "print octal escapes for nongraphic characters"),
blocksize = arg_int0(NULL,"block-size","SIZE", "use SIZE-byte blocks"),
B = arg_lit0("B", "ignore-backups", "do not list implied entries ending with ~"),
c = arg_lit0("c", NULL, "with -lt: sort by, and show, ctime (time of last"),
arg_rem(NULL, " modification of file status information)"),
arg_rem(NULL, " with -l: show ctime and sort by name"),
arg_rem(NULL, " otherwise: sort by ctime"),
C = arg_lit0("C", NULL, "list entries by columns"),
color = arg_str0(NULL,"color","WHEN", "control whether color is used to distinguish file"),
arg_rem(NULL, " types. WHEN may be `never', `always', or `auto'"),
d = arg_lit0("d", "directory", "list directory entries instead of contents,"),
arg_rem(NULL, " and do not dereference symbolic links"),
D = arg_lit0("D", "dired", "generate output designed for Emacs' dired mode"),
f = arg_lit0("f", NULL, "do not sort, enable -aU, disable -lst"),
F = arg_lit0("F", "classify", "append indicator (one of */=@|) to entries"),
format = arg_str0(NULL,"format","WORD", "across -x, commas -m, horizontal -x, long -l,"),
arg_rem (NULL, " single-column -1, verbose -l, vertical -C"),
fulltime = arg_lit0(NULL,"full-time", "like -l --time-style=full-iso"),
g = arg_lit0("g", NULL, "like -l, but do not list owner"),
G = arg_lit0("G", "no-group", "inhibit display of group information"),
h = arg_lit0("h", "human-readable", "print sizes in human readable format (e.g., 1K 234M 2G)"),
si = arg_lit0(NULL,"si", "likewise, but use powers of 1000 not 1024"),
H = arg_lit0("H", "dereference-command-line","follow symbolic links listed on the command line"),
deref = arg_lit0(NULL,"dereference-command-line-symlink-to-dir","follow each command line symbolic link"),
arg_rem(NULL, " that points to a directory"),
indic = arg_str0(NULL,"indicator-style","WORD","append indicator with style WORD to entry names:"),
arg_rem (NULL, " none (default), classify (-F), file-type (-p)"),
i = arg_lit0("i", "inode", "print index number of each file"),
I = arg_str0("I", "ignore","PATTERN", "do not list implied entries matching shell PATTERN"),
k = arg_lit0("k", NULL, "like --block-size=1K"),
l = arg_lit0("l", NULL, "use a long listing format"),
L = arg_lit0("L", "dereference", "when showing file information for a symbolic"),
arg_rem (NULL, " link, show information for the file the link"),
arg_rem (NULL, " references rather than for the link itself"),
m = arg_lit0("m", NULL, "fill width with a comma separated list of entries"),
n = arg_lit0("n", "numeric-uid-gid", "like -l, but list numeric UIDs and GIDs"),
N = arg_lit0("N", "literal", "print raw entry names (don't treat e.g. control"),
arg_rem (NULL, " characters specially)"),
o = arg_lit0("o", NULL, "like -l, but do not list group information"),
p = arg_lit0("p", "file-type", "append indicator (one of /=@|) to entries"),
q = arg_lit0("q", "hide-control-chars", "print ? instead of non graphic characters"),
shcont = arg_lit0(NULL,"show-control-chars", "show non graphic characters as-is (default"),
arg_rem (NULL, "unless program is `ls' and output is a terminal)"),
Q = arg_lit0("Q", "quote-name", "enclose entry names in double quotes"),
Qstyle = arg_str0(NULL,"quoting-style","WORD","use quoting style WORD for entry names:"),
arg_rem (NULL, " literal, locale, shell, shell-always, c, escape"),
r = arg_lit0("r", "reverse", "reverse order while sorting"),
R = arg_lit0("R", "recursive", "list subdirectories recursively"),
s = arg_lit0("s", "size", "print size of each file, in blocks"),
S = arg_lit0("S", NULL, "sort by file size"),
sort = arg_str0(NULL,"sort","WORD", "extension -X, none -U, size -S, time -t, version -v,"),
arg_rem (NULL, "status -c, time -t, atime -u, access -u, use -u"),
Time = arg_str0(NULL,"time","WORD", "show time as WORD instead of modification time:"),
arg_rem (NULL, " atime, access, use, ctime or status; use"),
arg_rem (NULL, " specified time as sort key if --sort=time"),
timesty = arg_str0(NULL, "time-style","STYLE", "show times using style STYLE:"),
arg_rem (NULL, " full-iso, long-iso, iso, locale, +FORMAT"),
arg_rem (NULL, "FORMAT is interpreted like `date'; if FORMAT is"),
arg_rem (NULL, "FORMAT1<newline>FORMAT2, FORMAT1 applies to"),
arg_rem (NULL, "non-recent files and FORMAT2 to recent files;"),
arg_rem (NULL, "if STYLE is prefixed with `posix-', STYLE"),
arg_rem (NULL, "takes effect only outside the POSIX locale"),
t = arg_lit0("t", NULL, "sort by modification time"),
T = arg_int0("T", "tabsize", "COLS", "assume tab stops at each COLS instead of 8"),
u = arg_lit0("u", NULL, "with -lt: sort by, and show, access time"),
arg_rem (NULL, " with -l: show access time and sort by name"),
arg_rem (NULL, " otherwise: sort by access time"),
U = arg_lit0("U", NULL, "do not sort; list entries in directory order"),
v = arg_lit0("v", NULL, "sort by version"),
w = arg_int0("w", "width", "COLS", "assume screen width instead of current value"),
x = arg_lit0("x", NULL, "list entries by lines instead of by columns"),
X = arg_lit0("X", NULL, "sort alphabetically by entry extension"),
one = arg_lit0("1", NULL, "list one file per line"),
help = arg_lit0(NULL,"help", "display this help and exit"),
version = arg_lit0(NULL,"version", "display version information and exit"),
files = arg_filen(NULL, NULL, "FILE", 0, argc+2, NULL),
end = arg_end(20),
};
const char *progname = "ls";
int exitcode=0;
int nerrors;
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0)
{
/* NULL entries were detected, some allocations must have failed */
printf("%s: insufficient memory\n",progname);
exitcode=1;
goto exit;
}
/* allow optional argument values for --color */
/* and set the default value to "always" */
color->hdr.flag |= ARG_HASOPTVALUE;
color->sval[0] = "always";
/* Parse the command line as defined by argtable[] */
nerrors = arg_parse(argc,argv,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("Usage: %s", progname);
arg_print_syntax(stdout,argtable,"\n");
printf("List information about the FILE(s) (the current directory by default).\n");
printf("Sort entries alphabetically if none of -cftuSUX nor --sort.\n\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
printf("\nSIZE may be (or may be an integer optionally followed by) one of following:\n"
"kB 1000, K 1024, MB 1,000,000, M 1,048,576, and so on for G, T, P, E, Z, Y.\n\n"
"By default, color is not used to distinguish types of files. That is\n"
"equivalent to using --color=none. Using the --color option without the\n"
"optional WHEN argument is equivalent to using --color=always. With\n"
"--color=auto, color codes are output only if standard output is connected\n"
"to a terminal (tty).\n\n"
"Report bugs to <foo@bar>.\n");
exitcode=0;
goto exit;
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0)
{
printf("'%s' example program for the \"argtable\" command line argument parser.\n",progname);
printf("September 2003, Stewart Heitmann\n");
exitcode=0;
goto exit;
}
/* If the parser returned any errors then display them and exit */
if (nerrors > 0)
{
/* Display the error details contained in the arg_end struct.*/
arg_print_errors(stdout,end,progname);
printf("Try '%s --help' for more information.\n",progname);
exitcode=1;
goto exit;
}
/* Command line parsing is complete, do the main processing */
exitcode = mymain();
exit:
/* deallocate each non-null entry in argtable[] */
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return exitcode;
}
int GRTCLCrackCommandLineData::ParseCommandLine(int argc, char *argv[]) {
int deviceCount, i;
std::vector<std::string> webTableFilenames;
// Command line argument parsing with argtable
struct arg_lit *verbose = arg_lit0("v", "verbose", "verbose output");
struct arg_lit *silent = arg_lit0(NULL, "silent", "silence all output");
// Table related options
struct arg_file *table_file = arg_filen(NULL,NULL,"<file>", 0, 10000, "GRT Tables to use");
struct arg_file *hash_file = arg_file0("f","hashfile","<file>", "Hashfile to use");
struct arg_str *hash_value = arg_str0("s", "hashstring", "hashstring", "The hash string");
struct arg_str *hash_type = arg_str1("h", "hashtype", "{NTLM, MD4, MD5, SHA1}", "hash type to crack");
// CUDA related params
struct arg_int *device = arg_int0("d", "device", "<n>", "OpenCL device to use");
struct arg_int *platform = arg_int0("p", "platform", "<n>", "OpenCL platform to use");
struct arg_int *m = arg_int0("m", "ms", "<n>", "target step time in ms");
struct arg_int *blocks = arg_int0("b", "blocks", "<n>", "number of thread blocks to run");
struct arg_int *threads = arg_int0("t", "threads", "<n>", "number of threads per block");
struct arg_lit *zerocopy = arg_lit0("z", "zerocopy", "use zerocopy memory");
struct arg_file *o = arg_file0("o", "outputfile", "outputfile", "output file for results");
// hexoutput: Adds hex output to all password outputs.
struct arg_lit *hex_output = arg_lit0(NULL, "hexoutput", "Adds hex output to all hash outputs");
struct arg_lit *amd_kernels = arg_lit0(NULL, "amd", "use AMD vector kernels");
struct arg_int *vector_width = arg_int0(NULL, "vectorwidth", "<n>", "vector width");
struct arg_lit *debug = arg_lit0(NULL, "debug", "Use debug display class");
struct arg_lit *devdebug = arg_lit0(NULL, "devdebug", "Developer debugging output");
struct arg_str *debugfiles = arg_str0(NULL, "debugdumpfiles", "<filename>", "Filename base to dump candidates and chains to");
struct arg_int *prefetch_count = arg_int0(NULL, "prefetch", "<n>", "number of prefetch threads");
struct arg_int *candidates_to_skip = arg_int0(NULL, "skip", "<n>", "number of candidate hashes to skip");
struct arg_str *table_url = arg_str0(NULL, "tableurl", "<URL>", "URL of the web table script");
struct arg_str *table_username = arg_str0(NULL, "tableusername", "<username>", "Username, if required, for the web table script");
struct arg_str *table_password = arg_str0(NULL, "tablepassword", "<password>", "Password, if required, for the web table script");
struct arg_end *end = arg_end(20);
void *argtable[] = {verbose,silent,table_file,hash_value,hash_file,hash_type,
device,platform,m,blocks,threads,zerocopy,o,amd_kernels,vector_width,
debug, devdebug, prefetch_count,table_url,table_username,table_password,
candidates_to_skip,debugfiles,hex_output,end};
// Get arguments, collect data, check for basic errors.
if (arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
}
// Look for errors
int nerrors = arg_parse(argc,argv,argtable);
if (nerrors > 0) {
// Print errors, exit.
arg_print_errors(stdout,end,argv[0]);
//arg_print_syntax(stdout,argtable,"\n\n");
printf("\n\nOptions: \n");
arg_print_glossary(stdout,argtable," %-20s %s\n");
exit(1);
}
// Verbose & silent
if (verbose->count) {
this->Verbose = 1;
}
if (silent->count) {
this->Silent = 1;
}
if (zerocopy->count) {
this->CUDAUseZeroCopy = 1;
}
if (debug->count) {
this->Debug = 1;
}
if (devdebug->count) {
this->Debug = 1;
this->DeveloperDebug = 1;
}
if (debugfiles->count) {
this->DebugDump = 1;
this->DebugDumpFilenameBase = *debugfiles->sval;
}
if (prefetch_count->count) {
this->NumberPrefetchThreads = *prefetch_count->ival;
}
if (candidates_to_skip->count) {
this->CandidateHashesToSkip = *candidates_to_skip->ival;
}
// Web table stuff
if (table_url->count) {
this->useWebTable = 1;
this->tableURL = *table_url->sval;
// If someone has NOT specified the candidates to skip, set to default.
if (!candidates_to_skip->count) {
this->CandidateHashesToSkip = DEFAULT_CANDIDATES_TO_SKIP;
}
}
if (table_username->count) {
this->tableUsername = *table_username->sval;
}
if (table_password->count) {
this->tablePassword = *table_password->sval;
}
this->HashType = this->GRTHashTypes->GetHashIdFromString(*hash_type->sval);
if (this->HashType == -1) {
printf("Unknown hash type %s: Exiting.\n\n", *hash_type->sval);
exit(1);
}
int correct_length = this->GRTHashTypes->GetHashLengthFromId(this->HashType);
// if we know the correct length, we make sure the hash is the correct length
if (correct_length != 0) {
if ((hash_value->count) && (strlen(*hash_value->sval) != correct_length)) {
printf("Hash string is not %d hex characters. Exiting.\n\n", correct_length);
exit(1);
}
}
if (hash_value->count) {
convertAsciiToBinary(*hash_value->sval, this->Hash, 16);
} else if (hash_file->count) {
this->hashFileName = hash_file->filename[0];
this->useHashFile = 1;
} else {
printf("Must provide a hash value or a hash file!\n");
exit(1);
}
if (o->count) {
this->outputHashFileName = o->filename[0];
this->useOutputHashFile = 1;
}
// Desired kernel time
if (m->count) {
this->KernelTimeMs = *m->ival;
}
// Do this to emulate CUDA behavior for now...
// Threads - if not set, leave at default 0
if (threads->count) {
this->OpenCLWorkitems = *threads->ival;
}
// Blocks - if not set, leave at default 0
if (blocks->count) {
this->OpenCLWorkgroups = *blocks->ival * this->OpenCLWorkitems;
}
if (hex_output->count) {
this->AddHexOutput = 1;
}
// Allocate space for the list of pointers
// Create the table header type
if (this->useWebTable) {
this->TableHeader = new GRTTableHeaderVWeb();
this->TableHeader->setWebURL(this->tableURL);
this->TableHeader->setWebUsername(this->tableUsername);
this->TableHeader->setWebPassword(this->tablePassword);
GRTTableHeaderVWeb *WebTableHeader =
(GRTTableHeaderVWeb *)this->TableHeader;
webTableFilenames = WebTableHeader->getHashesFromServerByType(this->HashType);
} else {
// V1 will work for both V1 & V2 types
this->TableHeader = new GRTTableHeaderV1();
}
// If we don't have any table filenames, get the ones from the web.
// Note: The script ONLY reutrns valid tables.
if ((table_file->count == 0) && this->useWebTable) {
this->Table_File_Count = webTableFilenames.size();
this->Table_Filenames = (char **)malloc(this->Table_File_Count * sizeof(char *));
for (i = 0; i < this->Table_File_Count; i++) {
// Increment size by 1 for null termination
this->Table_Filenames[i] = (char *)malloc((webTableFilenames.at(i).size() + 1) * sizeof(char));
strcpy(this->Table_Filenames[i], webTableFilenames.at(i).c_str());
}
} else {
this->Table_File_Count = table_file->count;
this->Table_Filenames = (char **)malloc(this->Table_File_Count * sizeof(char *));
// Handle the file list sanely
for (i = 0; i < table_file->count; i++) {
// Check to ensure the file is valid
if (!this->TableHeader->isValidTable(table_file->filename[i], -1)) {
printf("%s is not a valid GRT table! Exiting.\n", table_file->filename[i]);
exit(1);
}
// Check to ensure the file is of the right type
if (!this->TableHeader->isValidTable(table_file->filename[i], this->HashType)) {
printf("%s is not a valid %s GRT table!\n", table_file->filename[i],
this->GRTHashTypes->GetHashStringFromId(this->HashType));
exit(1);
}
// Increment size by 1 for null termination
this->Table_Filenames[i] = (char *)malloc((strlen(table_file->filename[i]) + 1) * sizeof(char));
strcpy(this->Table_Filenames[i], table_file->filename[i]);
}
}
// Finally, set the CUDA device and look for errors.
if (device->count) {
this->OpenCLDevice = *device->ival;
}
if (platform->count) {
this->OpenCLPlatform = *platform->ival;
}
if (amd_kernels->count) {
this->useAmdKernels = 1;
this->vectorWidth = 4;
}
if (vector_width->count) {
this->vectorWidth = *vector_width->ival;
}
}
int main(int argc, char *argv[]) {
SDL_AudioSpec want, have;
SDL_AudioDeviceID dev;
Streamer streamer;
int retcode = 0;
// Init SDL Audio
if(SDL_Init(SDL_INIT_AUDIO) != 0) {
fprintf(stderr, "Error: %s\n", SDL_GetError());
return 1;
}
// commandline argument parser options
struct arg_lit *help = arg_lit0("h", "help", "print this help and exit");
struct arg_lit *vers = arg_lit0("v", "version", "print version information and exit");
struct arg_file *file = arg_file1("f", "file", "<file>", "SOUNDS.DAT file");
struct arg_file *output = arg_file0("o", "output", "<file>", "Output sounds file");
struct arg_int *sid = arg_int0("s", "sound", "<int>", "Sound ID");
struct arg_int *sampleprint = arg_int0(NULL, "print", "<int>", "Print first n bytes from selected sound");
struct arg_lit *play = arg_lit0("p", "play", "Play selected sound");
struct arg_file *export = arg_file0("e", "export", "<file>", "Export selected sound to AU file");
struct arg_file *import = arg_file0("i", "import", "<file>", "Import selected sound from AU file");
struct arg_end *end = arg_end(20);
void* argtable[] = {help,vers,file,output,sid,sampleprint,play,export,import,end};
const char* progname = "soundtool";
// Make sure everything got allocated
if(arg_nullcheck(argtable) != 0) {
printf("%s: insufficient memory\n", progname);
goto exit_0;
}
// Parse arguments
int nerrors = arg_parse(argc, argv, argtable);
// Handle help
if(help->count > 0) {
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
printf("\nArguments:\n");
arg_print_glossary(stdout, argtable, "%-25s %s\n");
goto exit_0;
}
// Handle version
if(vers->count > 0) {
printf("%s v0.1\n", progname);
printf("Command line One Must Fall 2097 SOUNDS.DAT file editor.\n");
printf("Source code is available at https://github.com/omf2097 under MIT license.\n");
printf("(C) 2013 Tuomas Virtanen\n");
goto exit_0;
}
// Handle errors
if(nerrors > 0) {
arg_print_errors(stdout, end, progname);
printf("Try '%s --help' for more information.\n", progname);
goto exit_0;
}
// Open sounds.dat
sd_sound_file sf;
sd_sounds_create(&sf);
retcode = sd_sounds_load(&sf, file->filename[0]);
if(retcode) {
printf("Error %d: %s\n", retcode, sd_get_error(retcode));
goto exit_1;
}
if(sid->count > 0) {
// Sound ID to handle
int sound_id = sid->ival[0];
const sd_sound *sound = sd_sounds_get(&sf, sound_id-1);
if(sound == NULL) {
printf("Invalid sound ID");
goto exit_1;
}
if(sampleprint->count > 0) {
int count = (sampleprint->ival[0] > sound->len) ? sound->len : sampleprint->ival[0];
printf("Sample size = %d\n", sound->len);
printf("Unknown = %d\n", sound->unknown);
printf("Attempting to print %d first bytes.\n", count);
for(int i = 0; i < count; i++) {
unsigned int s = sound->data[i] & 0xFF;
printf("%2x ", s);
}
} else if(play->count > 0) {
printf("Attempting to play sample #%d.\n", sound_id);
// Make sure there is data at requested ID position
if(sound->len <= 0) {
printf("Sample does not contain data.\n");
goto exit_1;
}
// Streamer
streamer.size = sound->len;
streamer.pos = 0;
streamer.data = sound->data;
// Initialize required audio
SDL_zero(want);
want.freq = 8000;
want.format = AUDIO_U8;
want.channels = 1;
want.samples = 4096;
want.callback = stream;
want.userdata = &streamer;
// Open device, play file
dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0);
if(dev == 0) {
printf("Failed to open audio dev: %s\n", SDL_GetError());
goto exit_0;
} else {
if(have.format != want.format) {
printf("Could not get correct playback format.\n");
} else {
printf("Starting playback ...\n");
SDL_PauseAudioDevice(dev, 0);
while(streamer.pos < streamer.size) {
SDL_Delay(100);
}
printf("All done.\n");
}
SDL_CloseAudioDevice(dev);
}
} else if(import->count > 0) {
if(sd_sound_from_au(&sf, sound_id, import->filename[0]) != SD_SUCCESS) {
printf("Importing sample %d from file %s failed.\n", sound_id, import->filename[0]);
} else {
printf("Importing sample %d from file %s succeeded.\n", sound_id, import->filename[0]);
}
} else if(export->count > 0) {
if(sd_sound_to_au(&sf, sound_id, export->filename[0]) != SD_SUCCESS) {
printf("Exporting sample %d to file %s failed.\n", sound_id, export->filename[0]);
} else {
printf("Exporting sample %d to file %s succeeded.\n", sound_id, export->filename[0]);
}
} else {
/** Processes command line arguments using argtable library
<p>To add a smafeopt class backed command line argument,
perform the following steps:
<ol>
<li>Add public member in smafeopt.h (smafe)
<li>Assign default value in smafeopt.cpp (smafe)
<li>Define a new struct (arg_lit, arg_int etc) in this method
(processCommandLineArguments()) and add details (shortopts, longopts)
according to appropriate constructor
<li>Add this struct to void* argtable[] array
<li>Transfer the value from the struct to the smafeopt instance
(<i>if (nerrors == 0)</i> block)
</ol>
* @param argc number of command line arguments (from main())
* @param argv array of c-strings (from main())
* @param so initialized, empty smafeopt instance that is to be filled
*/
void processCommandLineArguments(int argc, char* argv[]) {
/* Define the allowable command line options, collecting them in argtable[] */
/* Syntax 1: command line arguments and file or dir */
// daemon options
struct arg_str
*arg_daemonID =
arg_str0(
NULL,
"id",
"IDENTIFIER",
"Identifier for daemon instance. IDENTIFIER must not contain whitespace or special chars.");
struct arg_int *arg_interval = arg_int0(NULL, "interval", "MINUTES",
"Polling interval in minutes. Default is 10");
struct arg_lit
*arg_no_daemon =
arg_lit0(NULL, "no-daemon",
"Runs program as normal forground process (no forking). No logfile allowed");
struct arg_str *arg_log = arg_str0(NULL, "log", "FILENAME",
"Name of logfile. If not specified, a random name is chosen.");
struct arg_lit *arg_stats = arg_lit0(NULL, "stats",
"Print number of open tasks and exit");
//struct arg_str *arg_passphrase = arg_str0("p", "passphrase", "PASSPHRASE", "Passphrase for database encryption (max 63 characters)");
struct arg_int
*arg_verbose =
arg_int0(
"v",
"verbosity",
"0-6",
"Set verbosity level (=log level). The lower the value the more verbose the program behaves. Default is 3");
struct arg_int *arg_lFvtId = arg_int1("f", "featurevectorype_id",
"FEATUREVECTORTYPE_ID",
"Featurevectortype_id to use. Must be contained in the database.");
struct arg_str *arg_dbconf = arg_str0(NULL, "dbconf", "DATABASE-CONFIGURATION-FILE",
"Specify file that contains database connection details");
struct arg_lit *help = arg_lit0(NULL, "help", "print this help and exit");
struct arg_end *end = arg_end(20);
void* argtable[] = { arg_daemonID, arg_lFvtId,
arg_no_daemon, arg_interval, arg_dbconf, arg_verbose, arg_log,
arg_stats, help, end };
int nerrors;
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0) {
/* NULL entries were detected, some allocations must have failed */
std::cerr << PROGNAME << ": insufficient memory" << std::endl;
exit(2);
}
// if no parameter is given: show help
if (argc > 1) {
// Parse the command line as defined by argtable[]
nerrors = arg_parse(argc, argv, argtable);
} else {
// no argument given
help->count = 1;
}
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0) {
std::cout << "Usage: " << PROGNAME;
arg_print_syntax(stdout, argtable, "\n");
std::cout << std::endl;
arg_print_glossary(stdout, argtable, " %-27s %s\n");
std::cout << "" << std::endl;
#if defined(SMAFEDISTD_REAL_DAEMON)
std::cout
<< "This program works as a daemon, i.e., it is executed in the background and not attached to a shell."
<< std::endl;
std::cout << std::endl;
std::cout
<< "Currently, the preferred way to stop a running daemon is sending a SIGTERM signal to it. Then, the program will exit after finishing the current job (if any)."
<< std::endl;
std::cout << std::endl;
std::cout << "How to send a SIGTERM signal to a running instance:"
<< std::endl;
std::cout << " 1) ps aux | grep " << PROGNAME
<< " (this gives you the <PID>)" << std::endl;
std::cout << " 2) kill <PID>" << std::endl;
#else
std::cout << "This program works NOT as a daemon because this platform does not support forking (or, there has been a problem at compiling the application)." << std::endl;
#endif
exit(1);
}
if (nerrors == 0) {
// verbosity level
// must be on top
if (arg_verbose->count > 0) {
loglevel_requested = arg_verbose->ival[0];
// change loglevel
SmafeLogger::smlog->setLoglevel(loglevel_requested);
} else
loglevel_requested = SmafeLogger::DEFAULT_LOGLEVEL;
// identifier
if (arg_daemonID->count > 0) {
daemonId = std::string(arg_daemonID->sval[0]);
if (daemonId == SmafeStoreDB::STATUSOK || (0 == daemonId.find(SmafeStoreDB::STATUSFAILED))) {
SMAFELOG_FUNC(SMAFELOG_FATAL, "Identifier " + daemonId + " is illegal. It must not be '"+SmafeStoreDB::STATUSOK+"' and must not start with '"+SmafeStoreDB::STATUSFAILED+"'");
exit(2);
}
} else {
if (arg_stats->count == 0) {
// is actually mandatory, only for --stats and --list it is not.
SMAFELOG_FUNC(SMAFELOG_FATAL, "Please specify an identifier for this daemon (--id).");
exit(2);
}
}
// logfile
// uses daemonId
if (arg_log->count > 0) {
sLogfilename = std::string(arg_log->sval[0]);
} else {
sLogfilename = std::string(PROGNAME) + "." + stringify(my_getpid())
+ ".log";
}
// no-daemon
if (arg_no_daemon->count > 0) {
#if defined(SMAFEDISTD_REAL_DAEMON)
if (arg_log->count > 0) {
SMAFELOG_FUNC(SMAFELOG_FATAL, "--no-daemon and --log cannot be combined. If program runs as forground process output is written to stdout and stderr.");
exit(1);
} else {
// no daemon
SMAFELOG_FUNC(SMAFELOG_INFO, "Running in 'normal mode' (ie, not as daemon)");
bNoDaemon = true;
}
#else
SMAFELOG_FUNC(SMAFELOG_INFO, "Parameter --no-daemon is implied since this executable is compiled without daemon mode support.");
#endif
}
// stats
if (arg_stats->count > 0) {
bPrintStatsOnly = true;
#if defined(SMAFEDISTD_REAL_DAEMON)
SMAFELOG_FUNC(SMAFELOG_INFO, "Stats mode, so running in 'normal mode' (ie, not as daemon)");
bNoDaemon = true;
#endif
} else
bPrintStatsOnly = false;
// polling interval
if (arg_interval->count > 0)
pollInterval = arg_interval->ival[0];
if (pollInterval == 0) {
SMAFELOG_FUNC(SMAFELOG_WARNING, "Polling interval set to 0 which means that the daemon will perform busy waiting.");
}
if (pollInterval < 0) {
SMAFELOG_FUNC(SMAFELOG_INFO, "Daemon will stop after last finished task (since pollInterval < 0)");
} else {
SMAFELOG_FUNC(SMAFELOG_INFO, "polling interval=" + stringify(pollInterval));
}
// fvtid
if (arg_lFvtId->count > 0)
lFvtId = arg_lFvtId->ival[0];
else {
SMAFELOG_FUNC(SMAFELOG_FATAL, "Specify fvtype_id");
exit(2);
}
if (lFvtId < 0) {
SMAFELOG_FUNC(SMAFELOG_FATAL, "Featurevectortype_id cannot be < 0");
exit(2);
}
// ---- db stuff
// db options file
if (arg_dbconf->count > 0) {
SMAFELOG_FUNC(SMAFELOG_DEBUG, "Parsing db configuration file");
so->parseDbOpts(std::string(arg_dbconf->sval[0]));
}
/*
// Passphrase
if (arg_passphrase->count > 0) {
if (strlen(arg_passphrase->sval[0]) <= 63) {
strcpy(verysecretpassphrase, arg_passphrase->sval[0]);
SMAFELOG_FUNC(SMAFELOG_INFO, "Data encryption / decryption is enabled.");
} else {
SMAFELOG_FUNC(SMAFELOG_FATAL, "Passphrase too long. Max 63 characters.");
exit(2);
}
} else {
SMAFELOG_FUNC(SMAFELOG_INFO, "Data encryption / decryption is DISABLED!");
}
*/
// switch to logfile was here
} else {
arg_print_errors(stdout, end, PROGNAME);
std::cout << "--help gives usage information" << std::endl;
exit(1);
}
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
}
int main(int argc, char **argv)
{
struct arg_lit *list = arg_lit0("lL",NULL, "list files");
struct arg_lit *recurse = arg_lit0("R",NULL, "recurse through subdirectories");
struct arg_int *repeat = arg_int0("k","scalar",NULL, "define scalar value k (default is 3)");
struct arg_str *defines = arg_strn("D","define","MACRO",0,argc+2, "macro definitions");
struct arg_file *outfile = arg_file0("o",NULL,"<output>", "output file (default is \"-\")");
struct arg_lit *verbose = arg_lit0("v","verbose,debug", "verbose messages");
struct arg_lit *help = arg_lit0(NULL,"help", "print this help and exit");
struct arg_lit *version = arg_lit0(NULL,"version", "print version information and exit");
struct arg_file *infiles = arg_filen(NULL,NULL,NULL,1,argc+2, "input file(s)");
struct arg_end *end = arg_end(20);
void* argtable[] = {list,recurse,repeat,defines,outfile,verbose,help,version,infiles,end};
const char* progname = "myprog";
int nerrors;
int exitcode=0;
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0)
{
/* NULL entries were detected, some allocations must have failed */
printf("%s: insufficient memory\n",progname);
exitcode=1;
goto exit;
}
/* set any command line default values prior to parsing */
repeat->ival[0]=3;
outfile->filename[0]="-";
/* Parse the command line as defined by argtable[] */
nerrors = arg_parse(argc,argv,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0)
{
printf("Usage: %s", progname);
arg_print_syntax(stdout,argtable,"\n");
printf("This program demonstrates the use of the argtable2 library\n");
printf("for parsing command line arguments.\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
exitcode=0;
goto exit;
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0)
{
printf("'%s' example program for the \"argtable\" command line argument parser.\n",progname);
printf("September 2003, Stewart Heitmann\n");
exitcode=0;
goto exit;
}
/* If the parser returned any errors then display them and exit */
if (nerrors > 0)
{
/* Display the error details contained in the arg_end struct.*/
arg_print_errors(stdout,end,progname);
printf("Try '%s --help' for more information.\n",progname);
exitcode=1;
goto exit;
}
/* special case: uname with no command line options induces brief help */
if (argc==1)
{
printf("Try '%s --help' for more information.\n",progname);
exitcode=0;
goto exit;
}
/* normal case: take the command line options at face value */
exitcode = mymain(list->count, recurse->count, repeat->ival[0],
defines->sval, defines->count,
outfile->filename[0], verbose->count,
infiles->filename, infiles->count);
exit:
/* deallocate each non-null entry in argtable[] */
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return exitcode;
}
int main(int argc, char *argv[]) {
#ifndef _OPENMP
fprintf(stderr, "\nERROR: Program built with compiler lacking OpenMP support.\n");
fprintf(stderr, "See SEAStAR README file for information about suitable compilers.\n");
exit(EXIT_FAILURE);
#endif
///////////////////////////
// Variable declarations
///////////////////////////
// Input filenames
UT_string *in_read1_fq_fn, *in_read2_fq_fn, *in_single1_fq_fn, *in_single2_fq_fn;
utstring_new(in_read1_fq_fn);
utstring_new(in_read2_fq_fn);
utstring_new(in_single1_fq_fn);
utstring_new(in_single2_fq_fn);
// Output filenames
UT_string *out_read1_fn, *out_read2_fn, *out_single1_fn, *out_single2_fn, *out_mates_fn, *out_filetype;
utstring_new(out_filetype);
utstring_new(out_read1_fn);
utstring_new(out_read2_fn);
utstring_new(out_single1_fn);
utstring_new(out_single2_fn);
utstring_new(out_mates_fn);
// Read name prefix
UT_string *out_read_prefix;
utstring_new(out_read_prefix);
// Flags
int singles_flag = 0; // 1 when two output singles files being written
int num_input_singles_files = 0;
// Read counters
unsigned long int mp_org = 0, R1_org = 0, R2_org = 0, singlet1_org = 0, singlet2_org = 0;
unsigned long int mp_cnt = 0, R1_cnt = 0, R2_cnt = 0, singlet1_cnt = 0, singlet2_cnt = 0, s1_cnt = 0, s2_cnt = 0;
unsigned long int comp_r1 = 0, comp_r2 = 0, comp_s1 = 0, comp_s2 = 0;
unsigned long int read1_singlet_cnt = 0, read2_singlet_cnt = 0;
////////////////////////////////////////////////////////////////////////
// All done with variable declarations!!
///////////////////////////////////
// Command line argtable settings
///////////////////////////////////
struct arg_lit *gzip = arg_lit0("z", "gzip", "Output converted files in gzip compressed format. [NULL]");
struct arg_lit *inv_singles = arg_lit0("v", "invert_singles", "Causes singles output to be the inverse of the input. 2->1 or 1->2 [NULL]");
struct arg_lit *num_singles = arg_lit0("s", "singles", "Write two singlet files, one for each mate-paired input file. [NULL]");
struct arg_rem *sing_rem = arg_rem(NULL, "Note! -v is only valid when there are input singlet reads. -s is only valid when there are NO input singlet reads.");
struct arg_str *pre_read_id = arg_str0(NULL, "prefix", "<string>", "Prefix to add to read identifiers. [out_prefix]");
struct arg_lit *no_pre = arg_lit0(NULL, "no_prefix", "Do not change the read names in any way. [NULL]");
struct arg_lit *pre_read_len = arg_lit0(NULL, "add_len", "Add the final trimmed length value to the read id prefix. [length not added]");
struct arg_dbl *prob = arg_dbl0("p","correct_prob","<d>","Probability that output reads are correct. 0.0 disables quality trimming. [0.5]");
struct arg_int *fixed_len = arg_int0("f","fixed_len","<u>","Trim all reads to a fixed length, still filtering on quality [no fixed length]");
struct arg_int *len = arg_int0("l","min_read_len","<u>","Minimum length of a singlet or longest-mate in nucleotides [24]");
struct arg_int *mate_len = arg_int0("m","min_mate_len","<u>","Minimum length of the shortest mate in nucleotides [min_read_len]");
struct arg_dbl *entropy = arg_dbl0("e","entropy_filter","<d>","Remove reads with per position information below given value (in bits per dinucleotide) [No filter]");
struct arg_lit *entropy_strict = arg_lit0(NULL, "entropy_strict", "Reject reads for low entropy overall, not just the retained part after trimming [NULL]");
struct arg_lit *mates = arg_lit0(NULL, "mates_file", "Produce a Velvet compatible interleaved paired read output file (e.g. <out_prefix>_mates.fastq). [NULL]");
struct arg_lit *no_rev = arg_lit0(NULL, "no_rev", "By default, the second read in each pair is reversed for colorspace --mate-file output. --no_rev disables reversing. [rev]");
struct arg_lit *only_mates = arg_lit0(NULL, "only_mates", "Supress writing .read1 and .read2 outputs. Requires --mates_file. [NULL]");
struct arg_lit *fasta = arg_lit0(NULL, "fasta", "Write FASTA format files instead of FASTQ for all outputs (e.g. <out_prefix>.<read_type>.fasta). [FASTQ]");
struct arg_file *input = arg_file1(NULL, NULL, "<in_prefix>", "Input file prefix: (e.g. <in_prefix>_single.fastq [<in_prefix>_read1.fastq <in_prefix>_read2.fastq]) ");
struct arg_file *output = arg_file1(NULL, NULL, "<out_prefix>", "Output file prefix: (e.g. <out_prefix>_single.fastq [<out_prefix>_read1.fastq <out_prefix>_read2.fastq]) ");
struct arg_lit *version = arg_lit0(NULL,"version","Print the build version and exit.");
struct arg_lit *h = arg_lit0("h", "help", "Request help.");
struct arg_end *end = arg_end(20);
void *argtable[] = {h,version,gzip,inv_singles,num_singles,sing_rem,prob,len,mate_len,fixed_len,pre_read_id,pre_read_len,no_pre,entropy,entropy_strict,mates,no_rev,only_mates,fasta,input,output,end};
int arg_errors = 0;
////////////////////////////////////////////////////////////////////////
// Handle command line processing (via argtable2 library)
////////////////////////////////////////////////////////////////////////
arg_errors = arg_parse(argc, argv, argtable);
if (version->count) {
fprintf(stderr, "%s version: %s\n", argv[0], SS_BUILD_VERSION);
exit(EXIT_SUCCESS);
}
if (h->count) {
fprintf(stderr,"\ntrim_fastq is a utility for performing quality and information-based\n");
fprintf(stderr,"trimming on paired or unpaired, nucleotide or SOLiD colorspace reads. \n\n");
arg_print_syntaxv(stderr, argtable, "\n\n");
arg_print_glossary(stderr, argtable, "%-25s %s\n");
fprintf(stderr, "\nInput and output \"prefixes\" are the part of the filename before:\n");
fprintf(stderr, "_single.fastq [_read1.fastq _read2.fastq] A singlets (single) file\n");
fprintf(stderr, "is required. Mate-paired read files are automatically used if present.\n");
fprintf(stderr, "Multiple output files only produced for mate-paired inputs.\n");
fprintf(stderr, "\nNote! Input and output files may be gzipped, and outputs can be written\n");
fprintf(stderr, "as either FASTQ or FASTA format files.\n");
exit(EXIT_FAILURE);
}
if (arg_errors) {
arg_print_errors(stderr, end, "trimfastq");
arg_print_syntaxv(stderr, argtable, "\n");
exit(EXIT_FAILURE);
}
// Validate entropy
if (entropy->count) {
entropy_cutoff = entropy->dval[0];
if ((entropy_cutoff < 0.0) || (entropy_cutoff > 4.0)) {
fprintf(stderr, "entropy_filter must be [0.0 - 4.0] \n");
exit(EXIT_FAILURE);
}
strict_ent = entropy_strict->count;
} else {
if (entropy_strict->count) {
fprintf(stderr, "Error: --entropy_strict requires --entropy_filter.\n");
exit(EXIT_FAILURE);
}
entropy_cutoff = -1.0;
}
// Validate error_prob
if (prob->count) {
err_prob = prob->dval[0];
if ((err_prob < 0.0) || (err_prob > 1.0)) {
fprintf(stderr, "--correct_prob (-p) must be 0.0 - 1.0 inclusive\n");
exit(EXIT_FAILURE);
}
} else {
err_prob = 0.5;
}
// Validate min read len
if (len->count) {
min_len = len->ival[0];
if (min_len <= 0) {
fprintf(stderr, "min_read_len must be > 0\n");
exit(EXIT_FAILURE);
}
} else {
min_len = 24;
}
// Validate min mate len
if (mate_len->count) {
min_mate_len = mate_len->ival[0];
if (min_mate_len <= 0) {
fprintf(stderr, "min_mate_len must be > 0\n");
exit(EXIT_FAILURE);
}
if (min_mate_len > min_len) {
fprintf(stderr, "min_mate_len must be <= min_len\n");
exit(EXIT_FAILURE);
}
} else {
min_mate_len = min_len;
}
if (fixed_len->count) {
fix_len = min_mate_len = min_len = fixed_len->ival[0];
if ((mate_len->count) || (len->count)) {
fprintf(stderr, "fixed_len cannot be used with min_read_len or min_mate_len\n");
exit(EXIT_FAILURE);
}
if (fix_len <= 0) {
fprintf(stderr, "fixed_len must be > 0\n");
exit(EXIT_FAILURE);
}
} else {
fix_len = 0;
}
if (pre_read_id->count) {
if (no_pre->count) {
fprintf(stderr, "Error: Both --prefix and --no_prefix were specified.\n");
exit(EXIT_FAILURE);
}
if (! strlen(pre_read_id->sval[0])) {
fprintf(stderr, "Read ID prefix may not be zero length.\n");
exit(EXIT_FAILURE);
}
if (strchr(pre_read_id->sval[0], ':') || strchr(pre_read_id->sval[0], '|') || strchr(pre_read_id->sval[0], '+') || strchr(pre_read_id->sval[0], '/')) {
fprintf(stderr, "Read ID prefix '%s' may not contain the characters ':', '|', '+' or '/'.\n", pre_read_id->sval[0]);
exit(EXIT_FAILURE);
}
// Build default read ID prefix
ss_strcat_utstring(out_read_prefix, pre_read_id->sval[0]);
} else {
if (!no_pre->count) {
if (strchr(output->filename[0], ':') || strchr(output->filename[0], '|') || strchr(output->filename[0], '+') || strchr(output->filename[0], '/')) {
fprintf(stderr, "Read ID prefix '%s' (from output prefix) may not contain the characters ':', '|', '+' or '/'.\n", output->filename[0]);
fprintf(stderr, "Hint: Use the --prefix parameter if the output file prefix contains path information.\n");
exit(EXIT_FAILURE);
}
// Build default read ID prefix
ss_strcat_utstring(out_read_prefix, output->filename[0]);
}
}
if ((only_mates->count) && (!mates->count)) {
fprintf(stderr, "--only_mates requires --mates.\n");
exit(EXIT_FAILURE);
}
if ((no_rev->count) && (!mates->count)) {
fprintf(stderr, "--no_rev requires --mates.\n");
exit(EXIT_FAILURE);
}
// Check for null string prefixes
if (!(strlen(input->filename[0]) && strlen(output->filename[0]))) {
fprintf(stderr, "Error: NULL prefix strings are not permitted.\n");
exit(EXIT_FAILURE);
}
// Construct input filenames
utstring_printf(in_read1_fq_fn, "%s.read1.fastq", input->filename[0]);
utstring_printf(in_read2_fq_fn, "%s.read2.fastq", input->filename[0]);
utstring_printf(in_single1_fq_fn, "%s.single.fastq", input->filename[0]);
FILE *in_read_file = NULL;
num_input_singles_files = 1;
// Try to open a singlet fastq file
// Check singlet output options -s and -v
// Set input singlet names to
// - *.single.fastq or
// - *.single1.fastq and *.single2.fastq
if (!(in_read_file = ss_get_gzFile(utstring_body(in_single1_fq_fn), "r"))) {
utstring_clear(in_single1_fq_fn);
utstring_printf(in_single1_fq_fn, "%s.single1.fastq", input->filename[0]);
utstring_printf(in_single2_fq_fn, "%s.single2.fastq", input->filename[0]);
num_input_singles_files = 2;
if ((in_read_file = ss_get_gzFile(utstring_body(in_single1_fq_fn), "r")) || (in_read_file = ss_get_gzFile(utstring_body(in_single2_fq_fn), "r"))) {
singles_flag = 1; // Two singlet outputs
} else {
singles_flag = num_singles->count; // Number of singlet outputs set by -s parm
if (inv_singles->count) {
fprintf(stderr, "Error: Invalid option -v, No input singlet file(s) found. Use -s to select multiple output singlet files.\n");
exit(EXIT_FAILURE);
}
}
}
if (in_read_file) {
gzclose(in_read_file);
if (num_singles->count) {
fprintf(stderr, "Error: Invalid option -s, Input singlet file(s) found, use -v to change the number of output singlet files.\n");
exit(EXIT_FAILURE);
}
}
// singles->count inverts the current singles file input scheme
singles_flag = (singles_flag ^ inv_singles->count);
// Check if input fastq is colorspace
// If some files are colorspace and some are basespace, throw an error
int fcount = 0;
int cscount = 0;
fcount += ss_is_fastq(utstring_body(in_read1_fq_fn));
fcount += ss_is_fastq(utstring_body(in_read2_fq_fn));
fcount += ss_is_fastq(utstring_body(in_single1_fq_fn));
fcount += ss_is_fastq(utstring_body(in_single2_fq_fn));
cscount += (ss_is_fastq(utstring_body(in_read1_fq_fn)) && ss_is_colorspace_fastq(utstring_body(in_read1_fq_fn)));
cscount += (ss_is_fastq(utstring_body(in_read2_fq_fn)) && ss_is_colorspace_fastq(utstring_body(in_read2_fq_fn)));
cscount += (ss_is_fastq(utstring_body(in_single1_fq_fn)) && ss_is_colorspace_fastq(utstring_body(in_single1_fq_fn)));
cscount += (ss_is_fastq(utstring_body(in_single2_fq_fn)) && ss_is_colorspace_fastq(utstring_body(in_single2_fq_fn)));
if (cscount && (cscount != fcount)) {
printf("Error: Mixed colorspace and basespace FASTQ files detected\n");
exit(EXIT_FAILURE);
}
colorspace_flag = cscount ? 1 : 0;
// Output filenames
if (fasta->count) {
ss_strcat_utstring(out_filetype, "fasta");
read_count_divisor = 2;
} else {
ss_strcat_utstring(out_filetype, "fastq");
read_count_divisor = 4;
}
if (!only_mates->count) {
utstring_printf(out_read1_fn, "%s.read1.%s", output->filename[0], utstring_body(out_filetype));
utstring_printf(out_read2_fn, "%s.read2.%s", output->filename[0], utstring_body(out_filetype));
}
if (singles_flag == 1) {
utstring_printf(out_single1_fn, "%s.single1.%s", output->filename[0], utstring_body(out_filetype));
utstring_printf(out_single2_fn, "%s.single2.%s", output->filename[0], utstring_body(out_filetype));
} else {
utstring_printf(out_single1_fn, "%s.single.%s", output->filename[0], utstring_body(out_filetype));
}
if (mates->count) {
utstring_printf(out_mates_fn, "%s.mates.%s", output->filename[0], utstring_body(out_filetype));
}
////////////////////////////////////////////////////////////////////////////////////////////////
// Begin processing!
#ifdef _OPENMP
omp_set_num_threads(10);
#endif
// This is the value of a non-valid pipe descriptor
#define NO_PIPE 0
int r1_pipe[2];
int r2_pipe[2];
int s1_pipe[2];
int s2_pipe[2];
pipe(r1_pipe);
pipe(r2_pipe);
pipe(s1_pipe);
pipe(s2_pipe);
int r1_out_pipe[2];
int r2_out_pipe[2];
int mates_out_pipe[2];
int s1_out_pipe[2];
int s2_out_pipe[2];
pipe(r1_out_pipe);
pipe(r2_out_pipe);
pipe(mates_out_pipe);
pipe(s1_out_pipe);
pipe(s2_out_pipe);
#pragma omp parallel sections default(shared)
{
#pragma omp section
{ // Read1 reader
fq_stream_trimmer(in_read1_fq_fn, r1_pipe[1], out_read_prefix, no_pre->count, pre_read_len->count, &comp_r1, &R1_org, '\0', fasta->count);
}
#pragma omp section
{ // Read1 writer
R1_cnt = ss_stream_writer(out_read1_fn, r1_out_pipe[0], gzip->count) / read_count_divisor;
}
#pragma omp section
{ // Read2 reader
fq_stream_trimmer(in_read2_fq_fn, r2_pipe[1], out_read_prefix, no_pre->count, pre_read_len->count, &comp_r2, &R2_org, '\0', fasta->count);
}
#pragma omp section
{ // Read2 writer
R2_cnt = ss_stream_writer(out_read2_fn, r2_out_pipe[0], gzip->count) / read_count_divisor;
}
#pragma omp section
{ // Single1 reader
// When there is only one input singles file, but two output singles files, then supply which mate to use for this stream in the split parameter
if ((singles_flag) && (num_input_singles_files == 1)) {
singlet1_cnt = fq_stream_trimmer(in_single1_fq_fn, s1_pipe[1], out_read_prefix, no_pre->count, pre_read_len->count, &comp_s1, &singlet1_org, '1', fasta->count);
} else {
singlet1_cnt = fq_stream_trimmer(in_single1_fq_fn, s1_pipe[1], out_read_prefix, no_pre->count, pre_read_len->count, &comp_s1, &singlet1_org, '\0', fasta->count);
}
}
#pragma omp section
{ // Single1 writer
s1_cnt = ss_stream_writer(out_single1_fn, s1_out_pipe[0], gzip->count) / read_count_divisor;
}
#pragma omp section
{ // Single2 reader
// When there is only one input singles file, but two output singles files, then supply which mate to use for this stream in the split parameter
if ((singles_flag) && (num_input_singles_files == 1)) {
singlet2_cnt = fq_stream_trimmer(in_single1_fq_fn, s2_pipe[1], out_read_prefix, no_pre->count, pre_read_len->count, &comp_s2, &singlet2_org, '2', fasta->count);
} else {
singlet2_cnt = fq_stream_trimmer(in_single2_fq_fn, s2_pipe[1], out_read_prefix, no_pre->count, pre_read_len->count, &comp_s2, &singlet2_org, '\0', fasta->count);
}
}
#pragma omp section
{ // Single2 writer
s2_cnt = ss_stream_writer(out_single2_fn, s2_out_pipe[0], gzip->count) / read_count_divisor;
}
#pragma omp section
{ // Velvet mates writer
// Divide count by 2 because both R1 and R2 reads go through this writer
mp_cnt = ss_stream_writer(out_mates_fn, mates_out_pipe[0], gzip->count) / 2 / read_count_divisor;
}
#pragma omp section
{ // Dispatcher
// Allocate data buffer strings
UT_string *r1_data;
utstring_new(r1_data);
UT_string *r2_data;
utstring_new(r2_data);
UT_string *s1_data;
utstring_new(s1_data);
UT_string *s2_data;
utstring_new(s2_data);
UT_string *rev_tmp;
utstring_new(rev_tmp);
UT_string *rev_data;
utstring_new(rev_data);
// Pipes
FILE *r1_in = fdopen(r1_pipe[0],"r");
FILE *r2_in = fdopen(r2_pipe[0],"r");
FILE *s1_in = fdopen(s1_pipe[0],"r");
FILE *s2_in = fdopen(s2_pipe[0],"r");
FILE *mates_out = fdopen(mates_out_pipe[1],"w");
FILE *r1_out = fdopen(r1_out_pipe[1],"w");
FILE *r2_out = fdopen(r2_out_pipe[1],"w");
FILE *s1_out = fdopen(s1_out_pipe[1],"w");
FILE *s2_out = fdopen(s2_out_pipe[1],"w");
if (!singles_flag) {
fclose(s2_out);
s2_out = s1_out;
}
// Flags for data left in single files
int single1_hungry = 1;
int single2_hungry = 1;
// Handle read1 and read2 files
while (ss_get_utstring(r1_in, r1_data)) {
if (!ss_get_utstring(r2_in, r2_data)) {
fprintf(stderr, "Error: Input read1 and read2 files are not synced\n");
exit(EXIT_FAILURE);
}
if (keep_read(r1_data)) {
if (keep_read(r2_data)) {
// Output both read1 and read2
if (mates->count) {
if (only_mates->count) {
// Interleaved velvet output only
output_read(r1_data, NULL, NULL, r1_in, NULL, mates_out, fasta->count);
if (no_rev->count || !colorspace_flag) {
output_read(r2_data, NULL, NULL, r2_in, NULL, mates_out, fasta->count);
} else {
output_read(r2_data, rev_data, rev_tmp, r2_in, NULL, mates_out, fasta->count);
}
} else {
// Interleaved velvet output and normal read file output
output_read(r1_data, NULL, NULL, r1_in, r1_out, mates_out, fasta->count);
if (no_rev->count || !colorspace_flag) {
output_read(r2_data, NULL, NULL, r2_in, r2_out, mates_out, fasta->count);
} else {
output_read(r2_data, rev_data, rev_tmp, r2_in, r2_out, mates_out, fasta->count);
}
}
} else {
// No interleaved velvet output
output_read(r1_data, NULL, NULL, r1_in, r1_out, NULL, fasta->count);
output_read(r2_data, NULL, NULL, r2_in, r2_out, NULL, fasta->count);
}
} else {
// Discard read2, output read1 as singlet
output_read(r1_data, NULL, NULL, r1_in, s1_out, NULL, fasta->count);
read1_singlet_cnt++;
}
} else {
if (keep_read(r2_data)) {
// Discard read1, output read2 as singlet
output_read(r2_data, NULL, NULL, r2_in, s2_out, NULL, fasta->count);
read2_singlet_cnt++;
}
}
// Process reads from singles here to take advantage of
// parallelism
if (single1_hungry || single2_hungry) {
if (single1_hungry) {
if (ss_get_utstring(s1_in, s1_data)) {
if (keep_read(s1_data)) {
output_read(s1_data, NULL, NULL, s1_in, s1_out, NULL, fasta->count);
}
} else {
single1_hungry = 0;
}
}
if (single2_hungry) {
if (ss_get_utstring(s2_in, s2_data)) {
if (keep_read(s2_data)) {
output_read(s2_data, NULL, NULL, s2_in, s2_out, NULL, fasta->count);
}
} else {
single2_hungry = 0;
}
}
}
}
while (single1_hungry || single2_hungry) {
if (single1_hungry) {
if (ss_get_utstring(s1_in, s1_data)) {
if (keep_read(s1_data)) {
output_read(s1_data, NULL, NULL, s1_in, s1_out, NULL, fasta->count);
}
} else {
single1_hungry = 0;
}
}
if (single2_hungry) {
if (ss_get_utstring(s2_in, s2_data)) {
if (keep_read(s2_data)) {
output_read(s2_data, NULL, NULL, s2_in, s2_out, NULL, fasta->count);
}
} else {
single2_hungry = 0;
}
}
}
fclose(r1_in);
fclose(r2_in);
fclose(s1_in);
fclose(s2_in);
fclose(mates_out);
fclose(r1_out);
fclose(r2_out);
fclose(s1_out);
if (singles_flag) {
fclose(s2_out);
}
// Free buffers
utstring_free(r1_data);
utstring_free(r2_data);
utstring_free(s1_data);
utstring_free(s2_data);
utstring_free(rev_tmp);
utstring_free(rev_data);
}
}
if (!(R1_org+singlet1_org+singlet2_org)) {
fprintf(stderr, "ERROR! No reads found in input files, or input(s) not found.\n");
exit(EXIT_FAILURE);
}
if (R1_org != R2_org) {
fprintf(stderr, "\nWarning! read1 and read2 fastq files did not contain an equal number of reads. %lu %lu\n", R1_org, R2_org);
}
if ((R1_org + R2_org) && !(singlet1_cnt + singlet2_cnt)) {
fprintf(stderr, "\nWarning! read1/read2 files were processed, but no corresponding input singlets were found.\n");
}
if (entropy->count) {
printf("\nLow complexity reads discarded: Read1: %lu, Read2: %lu, Singlets: %lu %lu\n", comp_r1, comp_r2, comp_s1, comp_s2);
}
mp_org = R1_org;
if (!only_mates->count) {
mp_cnt = R1_cnt;
}
printf("\nMatepairs: Before: %lu, After: %lu\n", mp_org, mp_cnt);
printf("Singlets: Before: %lu %lu After: %lu %lu\n", singlet1_org, singlet2_org, s1_cnt, s2_cnt);
printf("Read1 singlets: %lu, Read2 singlets: %lu, Original singlets: %lu %lu\n", read1_singlet_cnt, read2_singlet_cnt, singlet1_cnt, singlet2_cnt);
printf("Total Reads Processed: %lu, Reads retained: %lu\n", 2*mp_org+singlet1_org+singlet2_org, 2*mp_cnt+s1_cnt+s2_cnt);
utstring_free(in_read1_fq_fn);
utstring_free(in_read2_fq_fn);
utstring_free(in_single1_fq_fn);
utstring_free(in_single2_fq_fn);
utstring_free(out_read1_fn);
utstring_free(out_read2_fn);
utstring_free(out_single1_fn);
utstring_free(out_single2_fn);
utstring_free(out_mates_fn);
utstring_free(out_filetype);
utstring_free(out_read_prefix);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct arg_int *lport = arg_int0("p", "port", "<localport>", "listening port (default is 8888)");
struct arg_int *debug = arg_int0("d", "debug", "<level>", "debug output level (default is 4)");
#ifdef PUBKEY_DATA_
struct arg_str *key = arg_str0("k", "key", "<keyfile>", "public key file (default is built-in)");
#else
struct arg_str *key = arg_str0("k", "key", "<keyfile>", "public key file (default is pubkey)");
#endif
#ifdef ROOTPEM_DATA_
struct arg_str *certdb= arg_str0(NULL, "certdb", "<certfile>", "trusted CA database (default is built-in)");
#else
struct arg_str *certdb= arg_str0(NULL, "certdb", "<certfile>", "trusted CA database (default is root.pem)");
#endif
struct arg_lit *help = arg_lit0(NULL,"help", "print this help and exit");
struct arg_str *host = arg_str1(NULL, NULL, "<host>[:port]", "non-blocked TLS server");
struct arg_end *end = arg_end(20);
void *argtable[] = {lport, debug, key, certdb, help, host, end};
const char* progname = "telex-client";
int nerrors;
int ret=0;
assert(!arg_nullcheck(argtable));
// defaults:
lport->ival[0] = 8888;
debug->ival[0] = 3;
#ifdef PUBKEY_DATA_
key->sval[0] = NULL;
#else
key->sval[0] = "pubkey";
#endif
#ifdef ROOTPEM_DATA_
certdb->sval[0] = NULL;
#else
certdb->sval[0] = "root.pem";
#endif
nerrors = arg_parse(argc,argv,argtable);
if (help->count > 0) {
printf("Usage: %s", progname);
arg_print_syntax(stdout,argtable,"\n");
printf("\nEstablishes covert, encrypted tunnels, disguised as connections to <host>.\n\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
printf("\n");
ret = 0;
} else if (nerrors > 0) {
arg_print_errors(stdout,end,progname);
printf("Try '%s --help' for more information.\n", progname);
ret = 1;
} else if (argc == 1) {
printf("Try '%s --help' for more information.\n", progname);
ret = 0;
} else {
int port = 443;
char hstr[255];
assert(host->sval[0]);
strncpy(hstr, host->sval[0], sizeof(hstr)-1);
char *pstr=0;
strtok(hstr, ":");
pstr = strtok(NULL, ":");
if (pstr) {
port = strtol(pstr, NULL, 10);
if (port < 1 || port > 65535) {
fprintf(stderr, "Invalid remote port: %d", port);
return 1;
}
}
printf("WARNING: This software is an experimental prototype intended for\n");
printf(" researchers. It does not provide strong security and is\n");
printf(" UNSAFE FOR REAL-WORLD USE. For details of current limitations\n");
printf(" of our proof-of-concept, please see telex-client/ISSUES.\n");
ret = telex_client(lport->ival[0], port, debug->ival[0], hstr, key->sval[0], certdb->sval[0]);
}
arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0]));
return ret;
}
//! parse command line
static index_error parse_command_line (
index_data_t* index_data_, int argc, char *argv[] )
{ dbg_message (__func__);
// initialise the table of arguments
struct arg_lit *help = arg_lit0 (NULL,"help",
"print this help and exit");
struct arg_lit *version = arg_lit0 (NULL,"version",
"print version information and exit");
struct arg_int *port = arg_int0 ("p","port",NULL,
"the port to use (default is 29898)");
struct arg_int *max_serv = arg_int0 ("m","max",NULL,
"maximum number of servers (default is 65000)");
struct arg_end *end = arg_end (20);
void* argtable[] = {help,version,port,max_serv,end};
const char* progname = APP_NAME;
int nerrors;
index_error exitcode = FUNC_OK;
for (;;) {
// verify the argtable[] entries were allocated sucessfully
if (arg_nullcheck (argtable) != 0) {
fprintf (stderr, "%s: insufficient memory\n", progname);
exitcode = FUNC_MEMORY_ERROR;
break;
}
// set any command line default values prior to parsing
port->ival[0] = -1;
max_serv->ival[0] = -1;
// Parse the command line as defined by argtable[]
nerrors = arg_parse (argc,argv,argtable);
// special case: '--help' takes precedence over error reporting
if (help->count > 0) {
printf ("Usage: %s", progname);
arg_print_syntax (stdout,argtable,"\n");
printf ("This program runs a server index for aitown\n");
arg_print_glossary (stdout,argtable," %-25s %s\n");
break;
}
// special case: '--version' takes precedence error reporting
if (version->count > 0) {
/** @todo replace with proper version once the dynamic header is inplace */
printf ("'%s' version %s\n", progname, "1.0.0");
break;
}
// If the parser returned any errors then display them and exit
if (nerrors > 0) {
arg_print_errors (stderr,end,progname);
fprintf (stderr, "Try '%s --help' for more information.\n",progname);
exitcode = FUNC_GENERIC_ERROR;
break;
}
// sanity checking
if ( ( port->ival[0] <= 0 ) | ( port->ival[0] > 65535 ) ) {
fprintf (stderr, "Port number must be a positive integer.\n");
exitcode = FUNC_GENERIC_ERROR;
break;
}
if ( max_serv->ival[0] <= 0 ) {
fprintf (stderr, "Maximum number of connections must be a positive integer.\n");
exitcode = FUNC_GENERIC_ERROR;
break;
}
// copy values to proper place
if ( port->ival[0] != -1 ) {
index_data_->port = port->ival[0];
} else if ( index_data_->port == 0 ) {
index_data_->port = 29898;
}
if ( max_serv->ival[0] != -1 ) {
index_data_->max_serv = max_serv->ival[0];
} else if ( index_data_->max_serv == 0 ) {
index_data_->max_serv = 65000;
}
break;
}
// deallocate each non-null entry in argtable[] and return
arg_freetable (argtable,sizeof(argtable)/sizeof(argtable[0]));
return exitcode;
}
int
main(int argc, char **argv)
{
struct arg_int *channels = arg_int0("c", "channels", "<n>", "define number of channels (default is 1)");
struct arg_int *subscribers = arg_int0("s", "subscribers", "<n>", "define number of subscribers (default is 1)");
struct arg_str *server_name = arg_str0("S", "server", "<hostname>", "server hostname where messages will be published (default is \"127.0.0.1\")");
struct arg_int *server_port = arg_int0("P", "port", "<n>", "server port where messages will be published (default is 9080)");
struct arg_int *timeout = arg_int0(NULL, "timeout", "<n>", "timeout when waiting events on communication to the server (default is 1000)");
struct arg_int *verbose = arg_int0("v", "verbose", "<n>", "increase output messages detail (0 (default) - no messages, 1 - info messages, 2 - debug messages, 3 - trace messages");
struct arg_lit *help = arg_lit0(NULL, "help", "print this help and exit");
struct arg_lit *version = arg_lit0(NULL, "version", "print version information and exit");
struct arg_end *end = arg_end(20);
void* argtable[] = { channels, subscribers, server_name, server_port, timeout, verbose, help, version, end };
const char* progname = "subscriber";
int nerrors;
int exitcode = EXIT_SUCCESS;
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0) {
/* NULL entries were detected, some allocations must have failed */
printf("%s: insufficient memory\n", progname);
exitcode = EXIT_FAILURE;
goto exit;
}
/* set any command line default values prior to parsing */
subscribers->ival[0] = DEFAULT_CONCURRENT_CONN;
channels->ival[0] = DEFAULT_NUM_CHANNELS;
server_name->sval[0] = DEFAULT_SERVER_HOSTNAME;
server_port->ival[0] = DEFAULT_SERVER_PORT;
timeout->ival[0] = DEFAULT_TIMEOUT;
verbose->ival[0] = 0;
/* Parse the command line as defined by argtable[] */
nerrors = arg_parse(argc, argv, argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0) {
printf(DESCRIPTION_SUBSCRIBER, progname, VERSION, COPYRIGHT);
printf("Usage: %s", progname);
arg_print_syntax(stdout, argtable, "\n");
arg_print_glossary(stdout, argtable, " %-25s %s\n");
exitcode = EXIT_SUCCESS;
goto exit;
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0) {
printf(DESCRIPTION_SUBSCRIBER, progname, VERSION, COPYRIGHT);
exitcode = EXIT_SUCCESS;
goto exit;
}
/* If the parser returned any errors then display them and exit */
if (nerrors > 0) {
/* Display the error details contained in the arg_end struct.*/
arg_print_errors(stdout, end, progname);
printf("Try '%s --help' for more information.\n", progname);
exitcode = EXIT_FAILURE;
goto exit;
}
verbose_messages = verbose->ival[0];
/* normal case: take the command line options at face value */
exitcode = main_program(channels->ival[0], subscribers->ival[0], server_name->sval[0], server_port->ival[0], timeout->ival[0]);
exit:
/* deallocate each non-null entry in argtable[] */
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
return exitcode;
}
int main(int argc, char* argv[]) {
#ifdef BALL
double discountFactor = 0.9;
#else
#ifdef CART_POLE
double discountFactor = 0.95;
#else
#ifdef DOUBLE_CART_POLE
double discountFactor = 0.95;
#else
#ifdef MOUNTAIN_CAR
double discountFactor = 0.95;
#else
#ifdef ACROBOT
double discountFactor = 0.95;
#else
#ifdef BOAT
double discountFactor = 0.95;
#else
#ifdef CART_POLE_BINARY
double discountFactor = 0.95;
#else
#ifdef SWIMMER
double discountFactor = 0.95;
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
FILE* initFileFd = NULL;
state** initialStates = NULL;
unsigned int maxDepth = 0;
FILE* combinedFd = NULL;
FILE* results = NULL;
char str[1024];
unsigned int i = 0;
unsigned int minDepth = 1;
unsigned int crtDepth = 0;
unsigned int n = 0;
unsigned int maxNbIterations = 0;
unsigned int nbSteps = 0;
unsigned int timestamp = time(NULL);
int readFscanf = -1;
optimistic_instance* optimistic = NULL;
random_search_instance* random_search = NULL;
uct_instance* uct = NULL;
uniform_instance* uniform = NULL;
struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state");
struct arg_int* d = arg_int1("d", NULL, "<n>", "Maximum depth of an uniform tree which the number of call per step");
struct arg_int* d2 = arg_int0(NULL, "min", "<n>", "Minimun depth to start from (min > 0)");
struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps");
struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem");
struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs");
struct arg_end* end = arg_end(7);
int nerrors = 0;
void* argtable[7];
argtable[0] = initFile;
argtable[1] = d2;
argtable[2] = d;
argtable[3] = s;
argtable[4] = k;
argtable[5] = where;
argtable[6] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 7);
return EXIT_FAILURE;
}
initGenerativeModelParameters();
K = k->ival[0];
initGenerativeModel();
initFileFd = fopen(initFile->filename[0], "r");
readFscanf = fscanf(initFileFd, "%u\n", &n);
initialStates = (state**)malloc(sizeof(state*) * n);
for(; i < n; i++) {
readFscanf = fscanf(initFileFd, "%s\n", str);
initialStates[i] = makeState(str);
}
fclose(initFileFd);
if(d2->count)
minDepth = d2->ival[0];
maxDepth = d->ival[0];
maxNbIterations = K;
nbSteps = s->ival[0];
optimistic = optimistic_initInstance(NULL, discountFactor);
random_search = random_search_initInstance(NULL, discountFactor);
uct = uct_initInstance(NULL, discountFactor);
uniform = uniform_initInstance(NULL, discountFactor);
sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps);
results = fopen(str, "w");
for(crtDepth = 1; crtDepth < minDepth; crtDepth++)
maxNbIterations += pow(K, crtDepth+1);
for(crtDepth = minDepth; crtDepth <= maxDepth; crtDepth++) {
double averages[4] = {0.0, 0.0, 0.0, 0.0};
sprintf(str, "%s/%u_combined_%u_%u(%u)_%u.csv", where->filename[0], timestamp, K, crtDepth, maxNbIterations, nbSteps);
combinedFd = fopen(str, "w");
fprintf(combinedFd, "nbIterations,optimistic,optimistic(discounted),optimistic depth,random search,random search(discounted),random search depth,uct,uct(discounted),uct depth,uniform,uniform(discounted),uniform depth\n");
for(i = 0; i < n; i++) {
unsigned int j = 0;
double sumRewards = 0.0;
double discountedSumRewards = 0.0;
unsigned int sumDepths = 0;
state* crt = copyState(initialStates[i]);
optimistic_resetInstance(optimistic, crt);
for(; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
optimistic_keepSubtree(optimistic);
action* optimalAction = optimistic_planning(optimistic, maxNbIterations);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward);
freeState(crt);
crt = nextState;
sumRewards += reward;
sumDepths += optimistic_getMaxDepth(optimistic);
discountedSumRewards += optimistic->gammaPowers[j] * reward;
if(isTerminal < 0)
break;
}
optimistic_resetInstance(optimistic, crt);
freeState(crt);
fprintf(combinedFd, "%u,%.15f,%.15f,%.15f,",maxNbIterations, sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1)));
averages[0] += sumRewards;
printf("Optimistic : %uth initial state processed\n", i + 1);
sumRewards = 0.0;
discountedSumRewards = 0.0;
sumDepths = 0;
crt = copyState(initialStates[i]);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
random_search_resetInstance(random_search, crt);
action* optimalAction = random_search_planning(random_search, maxNbIterations);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward);
freeState(crt);
crt = nextState;
sumRewards += reward;
sumDepths += random_search_getMaxDepth(random_search);
discountedSumRewards += random_search->gammaPowers[j] * reward;
if(isTerminal < 0)
break;
}
random_search_resetInstance(random_search, crt);
freeState(crt);
fprintf(combinedFd, "%.15f,%.15f,%.15f,", sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1)));
averages[1] += sumRewards;
printf("Random search: %uth initial state processed\n", i + 1);
sumRewards = 0.0;
discountedSumRewards = 0.0;
sumDepths = 0;
crt = copyState(initialStates[i]);
uct_resetInstance(uct, crt);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
uct_keepSubtree(uct);
action* optimalAction = uct_planning(uct, maxNbIterations);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward);
freeState(crt);
crt = nextState;
sumRewards += reward;
sumDepths += uct_getMaxDepth(uct);
discountedSumRewards += uct->gammaPowers[j] * reward;
if(isTerminal < 0)
break;
}
uct_resetInstance(uct, crt);
freeState(crt);
fprintf(combinedFd, "%.15f,%.15f,%.15f,", sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1)));
averages[2] += sumRewards;
printf("Uct : %uth initial state processed\n", i + 1);
sumRewards = 0.0;
discountedSumRewards = 0.0;
crt = copyState(initialStates[i]);
uniform_resetInstance(uniform, crt);
for(j = 0; j < nbSteps; j++) {
char isTerminal = 0;
double reward = 0.0;
state* nextState = NULL;
uniform_keepSubtree(uniform);
action* optimalAction = uniform_planning(uniform, maxNbIterations);
isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward);
freeState(crt);
crt = nextState;
sumRewards += reward;
discountedSumRewards += uniform->gammaPowers[j] * reward;
if(isTerminal < 0)
break;
}
uniform_resetInstance(uniform, crt);
freeState(crt);
fprintf(combinedFd, "%.15f,%.15f,%u\n", sumRewards, discountedSumRewards, crtDepth -1);
fflush(combinedFd);
averages[3] += sumRewards;
printf("Uniform : %uth initial state processed\n", i + 1);
printf(">>>>>>>>>>>>>> %uth initial state processed\n", i + 1);
}
fprintf(results, "%u,%.15f,%.15f,%.15f,%.15f\n", maxNbIterations, averages[0] / (double)n, averages[1] / (double)n, averages[2] / (double)n, averages[3] / (double)n);
fflush(results);
printf(">>>>>>>>>>>>>> %u depth done\n\n", crtDepth);
fclose(combinedFd);
maxNbIterations += pow(K, crtDepth+1);
}
fclose(results);
arg_freetable(argtable, 7);
for(i = 0; i < n; i++)
freeState(initialStates[i]);
free(initialStates);
optimistic_uninitInstance(&optimistic);
random_search_uninitInstance(&random_search);
uct_uninitInstance(&uct);
uniform_uninitInstance(&uniform);
freeGenerativeModel();
freeGenerativeModelParameters();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
struct arg_int *serverport = arg_int0("pP","port","","serverport, default: 1337");
struct arg_str *serialport = arg_str0("sS", "serial", "", "serial port, default /dev/ttyS0");
struct arg_int *baud = arg_int0("bB", "baud","","baudrate, default: 9600");
struct arg_str *client = arg_str0("cC","client","","only accept messages from this client");
struct arg_lit *help = arg_lit0("hH","help","print this help and exit");
struct arg_lit *version = arg_lit0(NULL,"version","print version information and exit");
struct arg_lit *debug = arg_lit0(NULL,"debug","print debug messages");
struct arg_lit *silent = arg_lit0(NULL,"silent","print no messages");
struct arg_end *end = arg_end(20);
void* argtable[] = {serverport,serialport,baud,client,help,version,debug,silent,end};
int nerrors;
int exitcode=0;
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0) {
/* NULL entries were detected, some allocations must have failed */
printf("%s: insufficient memory\n",PROGNAME);
exitcode=1;
goto exit;
}
/* set any command line default values prior to parsing */
/* nothing */
/* Parse the command line as defined by argtable[] */
nerrors = arg_parse(argc,argv,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0) {
printf("usage: %s", PROGNAME);
arg_print_syntax(stdout,argtable,"\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
exitcode=0;
goto exit;
}
/* special case: '--version' takes precedence error reporting */
if (version->count > 0) {
printf("'%s' version ",PROGNAME);
printf("%s",VERSION);
printf("\nGIT-REVISION: ");
printf("%s",GITREV);
printf("\n%s receives udp-packets and controls\n",PROGNAME);
printf("the EIWOMISA controller over RS-232\n");
printf("%s",COPYRIGHT);
printf("\n");
exitcode=0;
goto exit;
}
/* If the parser returned any errors then display them and exit */
if (nerrors > 0) {
/* Display the error details contained in the arg_end struct.*/
arg_print_errors(stdout,end,PROGNAME);
printf("Try '%s --help' for more information.\n",PROGNAME);
exitcode=1;
goto exit;
}
/* special case: with no command line options induce brief help and use defaults */
if (argc==1) {
printf("No command-line options present, using defaults.\n",PROGNAME);
printf("Try '%s --help' for more information.\n",PROGNAME);
}
/* normal case: take the command line options at face value */
/* check if server port is set */
int i_serverport = -1;
if(serverport->count>0)
i_serverport = (int)serverport->ival[0];
/* check if serial port is set */
char* i_serialport = NULL;
if(serialport->count>0)
i_serialport = (char*)serialport->sval[0];
/* check if baudrate is set */
int i_baudrate = -1;
if(baud->count>0)
i_baudrate = (int)baud->ival[0];
/* check if client ip is set */
char* i_client = NULL;
if(client->count>0) {
i_client = (char *)client->sval[0];
}
/* --debug enables debug messages */
if (debug->count > 0) {
printf("debug messages enabled\n");
msglevel = 3;
}
/* --silent disables all (!) messages */
if (silent->count > 0) {
msglevel = 0;
}
exitcode = mymain(i_serverport, i_serialport, i_baudrate, i_client);
exit:
/* deallocate each non-null entry in argtable[] */
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return exitcode;
}
int main(int argc, char **argv) {
int exitcode = 0;
int nerrors = 0;
/* Prepare command line arguments */
struct arg_str *latero_ip = arg_str1(NULL,"latero_ip","IP", "Latero server IP address");
struct arg_lit *print_resp= arg_lit0("p", "print", "print response packet");
struct arg_int *numpkt = arg_int0("n", "numpkt","<n>", "How many packets (default is 1)");
struct arg_int *dacval = arg_intn(NULL,"dac","<int>",0,4,"dac values (up to 4 values)");
struct arg_lit *rd = arg_lit0("r", "read", "read");
struct arg_lit *wr = arg_lit0("w", "write", "write");
struct arg_int *addr = arg_int0("a", "addr",NULL, "address");
struct arg_int *value = arg_int0("v", "value",NULL, "value");
struct arg_lit *mainctrl = arg_lit0(NULL,"mainctrl", "Raw commands are for the main controller");
struct arg_int *tpat = arg_int0("t","testpat","<n>", "Run Test Pattern:1=Split, 2=AllPin, 3=RowCol");
struct arg_lit *latio = arg_lit0(NULL,"lateroio", "Raw commands are for the Latero IO card");
struct arg_lit *help = arg_lit0(NULL,"help", "print this help and exit");
struct arg_end *end = arg_end(10);
void* argtable[] = {latero_ip,print_resp,numpkt,dacval,
rd, wr, addr, value, mainctrl, tpat, latio,
help,end};
//latero_ip->sval[0] = "192.168.1.108";
/* verify the argtable[] entries were allocated sucessfully */
if (arg_nullcheck(argtable) != 0) {
/* NULL entries were detected, some allocations must have failed */
printf("Insufficient memory (argtable)\n");
exitcode = 1; goto exit;
}
numpkt->ival[0] = 1;
tpat->ival[0] = 0;
nerrors = arg_parse(argc,argv,argtable);
/* special case: '--help' takes precedence over error reporting */
if (help->count > 0) {
printf("Usage: %s", argv[0]);
arg_print_syntax(stdout,argtable,"\n");
printf("Latero client demonstration program version 1, revision 1\n");
arg_print_glossary(stdout,argtable," %-25s %s\n");
exitcode=0; goto exit;
}
if (nerrors > 0) {
/* Display the error details contained in the arg_end struct.*/
arg_print_errors(stdout,end,argv[0]);
printf("Try '%s --help' for more information.\n",argv[0]);
exitcode = 0; goto exit;
}
if( wr->count > 0 ) {
if( addr->count != 1 || value->count != 1 ) {
printf("Write requires an address and a value\n");
exitcode = 1; goto exit;
}
if( mainctrl->count + latio->count == 0 ) {
printf("Write requires a destination (--mainctrl or --lateroio)\n");
exitcode = 1; goto exit;
}
}
if( rd->count > 0 ) {
if( addr->count != 1 ) {
printf("Read requires an address\n");
exitcode = 1; goto exit;
}
if( mainctrl->count + latio->count == 0 ) {
printf("Read requires a destination (--mainctrl or --lateroio)\n");
exitcode = 1; goto exit;
}
}
return( my_main( latero_ip->sval[0], print_resp->count, numpkt->ival[0], dacval->ival, dacval->count,
rd->count, wr->count, addr->ival[0], value->ival[0], mainctrl->count, latio->count, tpat->ival[0]) );
exit:
printf("Program Ended\n");
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
return(exitcode);
}
