int clockwrapper() {
return (int) times(NULL);
}
void Timer::cont() {
tms buffer;
mRealTime = times(&buffer)/sHZ;
mUserTime = buffer.tms_utime/sHZ;
mSysTime = buffer.tms_stime/sHZ;
}
int main() {
char input[MAXSIZE]; // Input from the user
char *args[MAXARGS]; // Array of arguments
char *command; // Holds the result of the strtok function
char *redir_in; // Holds the input redirection file
char *redir_out; // Holds the output redirection file
struct tms timer_start; // Holds the CPU start time struct
struct tms timer_end; // Holds the CPU end time struct
time_t real_start; // Stores the starting real time
time_t real_end; // Stores the ending real time
int counter = 1; // A counter next to the input line
int status = 0; // Stores the error status
int num_args = 0; // Stores the number of arguments in the current command
char timer = 0; // Boolean if "time" was entered first
char read = 0; // Boolean for input redirection
char write = 0; // Boolean for output redirection
while (1) {
printf("(%d) blueshell $ ", counter); // "blueshell" pays homage to the notorious Mario Kart item
if (!fgets(input, 1000, stdin)) { // Exits the shell if fgets returns NULL
return 1;
}
if (strlen(input) <= 1) { // Continues the loop if an empty string is entered
continue;
}
num_args = 0; // Resets the associated accumulators and booleans
timer = 0;
read = 0;
write = 0;
errno = 0;
status = 0;
counter++; // Increments the shell counter
redir_in = strchr(input, '<'); // Searches for the input redirection character
redir_out = strchr(input, '>'); // Searches for the output redirection character
if (redir_in != NULL) { // Stores the input file if redir_in is not null
redir_in = strtok(redir_in, DELIMS);
read = 1;
}
if (redir_out != NULL) { // Stores the output file if redir_in is not null
redir_out = strtok(redir_out, DELIMS);
write = 1;
}
command = strtok(input, DELIMS); // Delimits the first token in the input
if (command == NULL) { // Continues the loop if the token is null
continue;
}
if (0 == strcmp(command, "exit")) { // Exits the shell if the token is "exit"
exit(0);
}
if (0 == strcmp(command, "time")) { // Starts the CPU timer if the token is "time"
command = strtok(NULL, DELIMS); // Gets the next token (since time is not included as a command)
timer = 1; // Sets the time boolean to "true"
real_start = time(NULL); // Sets the realtime start
times(&timer_start); // Sets the CPU times start
}
while (command != NULL) { // Loops while there is something to tokenize
char valid = 1; // Boolean validating the token
if (read) {
if (0 == strcmp(command, redir_in)) { // Keeps the input redirection file out of the arguments
valid = 0;
}
}
if (write) {
if (0 == strcmp(command, redir_out)) { // Keeps the output redirection file out of the arguments
valid = 0;
}
}
if (valid) {
args[num_args++] = command; // If the argument is valid, it is added to the array and the arg_count is incremeneted
}
command = strtok(NULL, DELIMS); // Gets the next token of the input
}
if (num_args < MAXARGS) {
args[num_args] = NULL; // Sets the pointer after the last argument to null
}
else {
printf("-blueshell: %s: Arg list too long\n", args[0]); // Prints an error if the maximum number of arguments have been reached
continue;
}
if (args[0] != NULL) { // Checks various conditions if a command has been entered
if (0 == strcmp(args[0], "cd")) { // Conditional if the command is "cd"
if (num_args > 1) { // Conditional if there are arguments for "cd"
if ('~' == args[1][0]) { // Conditional if the first character is a tilde
char *path; // Holds the Pitt Net path prefix
char *argument; // Stores the modified argument
int len = 0; // Length of the argument
argument = strtok(args[1], "~"); // Tokenizes the argument of the tilde
len = strlen(argument); // Gets the length of the modified argument
path = malloc(len * sizeof(char) + 24 * sizeof(char)); // Allocates memory for the full path string
strcpy(path, "/afs/pitt.edu/home/"); // Builds a string of the full pathname
strncat(path, argument, 1);
strncat(path, "/", 1);
strncat(path, argument + 1 * sizeof(char), 1);
strncat(path, "/", 1);
strcat(path, argument);
status = chdir(path); // Attempts to change the current directory
free(path); // Frees memory allocated for the string
}
else {
status = chdir(args[1]); // Otherwise, changes the directory to the argument specified
}
}
else { // Otherwise, changes to the default directory of the user
char *path; // Pointer to the pathname
char *user; // Pointer to the username
int len = 0; // Length of the full pathname
user = getlogin(); // Gets the username
len = strlen(user); // Gets the length of the username
path = malloc(len * sizeof(char) + 24 * sizeof(char)); // Allocates memory for the path
strcpy(path, "/afs/pitt.edu/home/"); // Builds the default pathname
strncat(path, user, 1);
strncat(path, "/", 1);
strncat(path, user + 1 * sizeof(char), 1);
strncat(path, "/", 1);
strcat(path, user);
status = chdir(path); // Attempts to change the current directory
free(path); // Frees memory allocated for the string
}
if (status < 0) { // If chdir() returned -1, prints the errno message
print_error(args[1]);
}
}
else { // Otherwise, attempts to fork the process and call execvp()
int pid = fork(); // Gets the process ID
if (0 == pid) { // The child process has an ID of 0
if (read) { // If input redirection is true
if (freopen(redir_in, "r", stdin) == NULL) { // Prints an error if the file descriptor is null
print_error(redir_in);
_exit(-1);
}
}
if (write) { // If output redirection is true
if (freopen(redir_out, "w", stdout) == NULL) { // Prints an error if the file descriptor is null
print_error(redir_out);
_exit(-1);
}
}
status = execvp(args[0], args); // Attempts to run the command and associated arguments
if (status < 0) { // Prints an eror if execvp returns -1
print_error(args[0]);
_exit(-1);
}
_exit(0);
}
else if (pid < 0) { // If the process ID is negative, prints an error
print_error(args[0]);
_exit(-1);
}
else { // Otherwise, the process is the parent
wait(&status); // Waits for the child process to complete
if (status < 0) { // Prints an error if the status is -1
print_error(args[0]);
}
}
}
}
if (timer) { // Gets the end real, user, and system times
times(&timer_end); // Gets the ending CPU times
real_end = time(NULL); // Gets the realtime end
printf("real\t%lds\n", real_end - real_start); // Prints the elapsed real time
printf("user\t%jds\n", (intmax_t)(timer_end.tms_cutime - timer_start.tms_cutime)); // Prints the user CPU time
printf("sys\t%jds\n", (intmax_t)(timer_end.tms_cstime - timer_start.tms_cstime)); // Prints the system CPU time
}
}
}
/*
| Normal operation happens in here.
*/
static void
masterloop(lua_State *L)
{
while( true )
{
bool have_alarm;
bool force_alarm = false;
clock_t now = times( dummy_tms );
clock_t alarm_time = 0;
// memory usage debugging
// lua_gc( L, LUA_GCCOLLECT, 0 );
// printf(
// "gccount: %d\n",
// lua_gc( L, LUA_GCCOUNT, 0 ) * 1024 + lua_gc( L, LUA_GCCOUNTB, 0 ) );
//
// queries the runner about the soonest alarm
//
load_runner_func( L, "getAlarm" );
if( lua_pcall( L, 0, 1, -2 ) )
{
exit( -1 );
}
if( lua_type( L, -1 ) == LUA_TBOOLEAN)
{
have_alarm = false;
force_alarm = lua_toboolean( L, -1 );
}
else
{
have_alarm = true;
alarm_time = *( ( clock_t * ) luaL_checkudata( L, -1, "Lsyncd.jiffies" ) );
}
lua_pop( L, 2 );
if(
force_alarm ||
( have_alarm && time_before_eq( alarm_time, now ) )
)
{
// there is a delay that wants to be handled already thus instead
// of reading/writing from observances it jumps directly to
// handling
// TODO: Actually it might be smarter to handler observances
// eitherway. since event queues might overflow.
logstring( "Masterloop", "immediately handling delays." );
}
else
{
// uses select( ) to determine what happens next:
// a) a new event on an observance
// b) an alarm on timeout
// c) the return of a child process
struct timespec tv;
if( have_alarm )
{
// TODO use trunc instead of long converstions
double d = ( (double )( alarm_time - now ) ) / clocks_per_sec;
tv.tv_sec = d;
tv.tv_nsec = ( (d - ( long ) d) ) * 1000000000.0;
printlogf(
L, "Masterloop",
"going into select ( timeout %f seconds )",
d
);
}
else
{
logstring(
"Masterloop",
"going into select ( no timeout )"
);
}
// time for Lsyncd to try to put itself to rest into the big select( )
// this configures:
// timeouts,
// filedescriptors and
// signals
// that will wake Lsyncd
{
fd_set rfds;
fd_set wfds;
sigset_t sigset;
int pi, pr;
sigemptyset( &sigset );
FD_ZERO( &rfds );
FD_ZERO( &wfds );
for( pi = 0; pi < observances_len; pi++ )
{
struct observance *obs = observances + pi;
if ( obs->ready )
{
FD_SET( obs->fd, &rfds );
}
if ( obs->writey )
{
FD_SET( obs->fd, &wfds );
}
}
if( !observances_len )
{
logstring(
"Error",
"Internal fail, no observances, no monitor!"
);
exit( -1 );
}
// the great select, this is the very heart beat of Lsyncd
// that puts Lsyncd to sleep until anything worth noticing
// happens
pr = pselect(
observances[ observances_len - 1 ].fd + 1,
&rfds,
&wfds,
NULL,
have_alarm ? &tv : NULL,
&sigset
);
// something happened!
if (pr >= 0)
{
// walks through the observances calling ready/writey
observance_action = true;
for( pi = 0; pi < observances_len; pi++ )
{
struct observance *obs = observances + pi;
// Checks for signals
if( hup || term )
{
break;
}
// a file descriptor became read-ready
if( obs->ready && FD_ISSET( obs->fd, &rfds ) )
{
obs->ready(L, obs);
}
// Checks for signals, again, better safe than sorry
if ( hup || term )
{
break;
}
// FIXME breaks on multiple nonobservances in one beat
if(
nonobservances_len > 0 &&
nonobservances[ nonobservances_len - 1 ] == obs->fd
)
{
continue;
}
// a file descriptor became write-ready
if( obs->writey && FD_ISSET( obs->fd, &wfds ) )
{
obs->writey( L, obs );
}
}
observance_action = false;
// works through delayed nonobserve_fd() calls
for (pi = 0; pi < nonobservances_len; pi++)
{
nonobserve_fd( nonobservances[ pi ] );
}
nonobservances_len = 0;
}
}
}
// collects zombified child processes
while( 1 )
{
int status;
pid_t pid = waitpid( 0, &status, WNOHANG );
if (pid <= 0)
{
// no more zombies
break;
}
// calls the runner to handle the collection
load_runner_func( L, "collectProcess" );
lua_pushinteger( L, pid );
lua_pushinteger( L, WEXITSTATUS( status ) );
if ( lua_pcall( L, 2, 0, -4 ) )
{ exit(-1); }
lua_pop( L, 1 );
}
// reacts on HUP signals
if( hup )
{
load_runner_func( L, "hup" );
if( lua_pcall( L, 0, 0, -2 ) )
{
exit( -1 );
}
lua_pop( L, 1 );
hup = 0;
}
// reacts on TERM and INT signals
if( term == 1 )
{
load_runner_func( L, "term" );
lua_pushnumber( L, sigcode );
if( lua_pcall( L, 1, 0, -3 ) )
{
exit( -1 );
}
lua_pop( L, 1 );
term = 2;
}
// lets the runner do stuff every cycle,
// like starting new processes, writing the statusfile etc.
load_runner_func( L, "cycle" );
l_now( L );
if( lua_pcall( L, 1, 1, -3 ) )
{
exit( -1 );
}
if( !lua_toboolean( L, -1 ) )
{
// cycle told core to break mainloop
lua_pop( L, 2 );
return;
}
lua_pop( L, 2 );
if( lua_gettop( L ) )
{
logstring(
"Error",
"internal, stack is dirty."
);
l_stackdump( L );
exit( -1 );
}
}
}
int main(int argc, char *argv[])
{
struct tms ini_tms, parent_tms, child_tms;
int status;
pid_t child, ctl;
clock_t st_time, cur_time;
output_init();
st_time = times(&ini_tms);
if (st_time == -1)
UNRESOLVED(errno, "times failed");
if (ini_tms.tms_cutime != 0 || ini_tms.tms_cstime != 0)
FAILED("The process is created with non-zero tms_cutime or "
"tms_cstime");
#if VERBOSE > 1
output("Starting loop...\n");
#endif
/* Busy loop for some times */
do {
cur_time = times(&parent_tms);
if (cur_time == (clock_t) - 1)
UNRESOLVED(errno, "times failed");
} while ((cur_time - st_time) < sysconf(_SC_CLK_TCK));
#if VERBOSE > 1
output("Busy loop terminated\n");
output
(" Real time: %ld, User Time %ld, System Time %ld, Ticks per sec %ld\n",
(long)(cur_time - st_time),
(long)(parent_tms.tms_utime - ini_tms.tms_utime),
(long)(parent_tms.tms_stime - ini_tms.tms_stime),
sysconf(_SC_CLK_TCK));
#endif
/* Create the child */
child = fork();
if (child == -1)
UNRESOLVED(errno, "Failed to fork");
/* child */
if (child == 0) {
cur_time = times(&child_tms);
if (cur_time == (clock_t) - 1)
UNRESOLVED(errno, "times failed");
if ((child_tms.tms_utime + child_tms.tms_stime) >=
sysconf(_SC_CLK_TCK))
FAILED("The tms struct was not reset during fork "
"operation");
do {
cur_time = times(&child_tms);
if (cur_time == -1)
UNRESOLVED(errno, "times failed");
} while ((child_tms.tms_utime + child_tms.tms_stime) <= 0);
/* We're done */
exit(PTS_PASS);
}
/* Parent joins the child */
ctl = waitpid(child, &status, 0);
if (ctl != child)
UNRESOLVED(errno, "Waitpid returned the wrong PID");
if (!WIFEXITED(status) || WEXITSTATUS(status) != PTS_PASS)
FAILED("Child exited abnormally");
/* Check the children times were reported as expected */
cur_time = times(&parent_tms);
#if VERBOSE > 1
output("Child joined\n");
output(" Real time: %ld,\n"
" User Time %ld, System Time %ld,\n"
" Child User Time %ld, Child System Time %ld\n",
(long)(cur_time - st_time),
(long)(parent_tms.tms_utime - ini_tms.tms_utime),
(long)(parent_tms.tms_stime - ini_tms.tms_stime),
(long)(parent_tms.tms_cutime - ini_tms.tms_cutime),
(long)(parent_tms.tms_cstime - ini_tms.tms_cstime)
);
#endif
if (cur_time == -1)
UNRESOLVED(errno, "times failed");
if (parent_tms.tms_cutime == 0 && parent_tms.tms_cstime == 0)
FAILED("The process is created with non-zero tms_cutime or "
"tms_cstime");
/* Test passed */
#if VERBOSE > 0
output("Test passed\n");
#endif
PASSED;
}
/*
Returns true if the real time clock has changed by more than 10%
relative to the processor time since the last time this function was
called. This presumably means that the system time has been changed.
If /a delta is nonzero, delta is set to our best guess at how much the system clock was changed.
*/
bool QTimerInfoList::timeChanged(timeval *delta)
{
#ifdef Q_OS_NACL
Q_UNUSED(delta)
return false; // Calling "times" crashes.
#endif
struct tms unused;
clock_t currentTicks = times(&unused);
clock_t elapsedTicks = currentTicks - previousTicks;
timeval elapsedTime = currentTime - previousTime;
timeval elapsedTimeTicks;
elapsedTimeTicks.tv_sec = elapsedTicks / ticksPerSecond;
elapsedTimeTicks.tv_usec = (((elapsedTicks * 1000) / ticksPerSecond) % 1000) * 1000;
timeval dummy;
if (!delta)
delta = &dummy;
*delta = elapsedTime - elapsedTimeTicks;
previousTicks = currentTicks;
previousTime = currentTime;
Proc0(long numloops, boolean print_result)
{
OneToFifty IntLoc1;
REG OneToFifty IntLoc2;
OneToFifty IntLoc3;
REG char CharLoc;
REG char CharIndex;
Enumeration EnumLoc;
String30 String1Loc;
String30 String2Loc;
// extern char *malloc();
register unsigned int i;
#ifdef TIME
long time();
long starttime;
long benchtime;
long nulltime;
starttime = time( (long *) 0);
for (i = 0; i < numloops; ++i);
nulltime = time( (long *) 0) - starttime; /* Computes o'head of loop */
#endif
#ifdef TIMES
time_t starttime;
time_t benchtime;
time_t nulltime;
struct tms tms;
times(&tms); starttime = tms.tms_utime;
for (i = 0; i < numloops; ++i);
times(&tms);
nulltime = tms.tms_utime - starttime; /* Computes overhead of looping */
#endif
#ifdef GETRUSAGE
struct rusage starttime;
struct rusage endtime;
struct timeval nulltime;
getrusage(RUSAGE_SELF, &starttime);
for (i = 0; i < numloops; ++i);
getrusage(RUSAGE_SELF, &endtime);
nulltime.tv_sec = endtime.ru_utime.tv_sec - starttime.ru_utime.tv_sec;
nulltime.tv_usec = endtime.ru_utime.tv_usec - starttime.ru_utime.tv_usec;
#endif
PtrGlbNext = (RecordPtr) malloc(sizeof(RecordType));
PtrGlb = (RecordPtr) malloc(sizeof(RecordType));
PtrGlb->PtrComp = PtrGlbNext;
PtrGlb->Discr = Ident1;
PtrGlb->EnumComp = Ident3;
PtrGlb->IntComp = 40;
strcpy(PtrGlb->StringComp, "DHRYSTONE PROGRAM, SOME STRING");
#ifndef GOOF
strcpy(String1Loc, "DHRYSTONE PROGRAM, 1'ST STRING"); /*GOOF*/
#endif
Array2Glob[8][7] = 10; /* Was missing in published program */
/*****************
-- Start Timer --
*****************/
#ifdef TIME
starttime = time( (long *) 0);
#endif
#ifdef TIMES
times(&tms); starttime = tms.tms_utime;
#endif
#ifdef GETRUSAGE
getrusage (RUSAGE_SELF, &starttime);
#endif
for (i = 0; i < numloops; ++i)
{
Proc5();
Proc4();
IntLoc1 = 2;
IntLoc2 = 3;
strcpy(String2Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
EnumLoc = Ident2;
BoolGlob = ! Func2(String1Loc, String2Loc);
while (IntLoc1 < IntLoc2)
{
IntLoc3 = 5 * IntLoc1 - IntLoc2;
Proc7(IntLoc1, IntLoc2, &IntLoc3);
++IntLoc1;
}
Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3);
Proc1(PtrGlb);
for (CharIndex = 'A'; CharIndex <= Char2Glob; ++CharIndex)
if (EnumLoc == Func1(CharIndex, 'C'))
Proc6(Ident1, &EnumLoc);
IntLoc3 = IntLoc2 * IntLoc1;
IntLoc2 = IntLoc3 / IntLoc1;
IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1;
Proc2(&IntLoc1);
}
/*****************
-- Stop Timer --
*****************/
if (print_result) {
#ifdef TIME
benchtime = time( (long *) 0) - starttime - nulltime;
printf("Dhrystone(%s) time for %ld passes = %ld\n",
Version,
(long) numloops, benchtime);
printf("This machine benchmarks at %ld dhrystones/second\n",
((long) numloops) / benchtime);
printf(" %ld DMIPS\n",
((long) numloops) / benchtime / ONE_MIPS);
#endif
#ifdef TIMES
times(&tms);
benchtime = tms.tms_utime - starttime - nulltime;
printf("Dhrystone(%s) time for %ld passes = %ld\n",
Version,
(long) numloops, benchtime/HZ);
printf("This machine benchmarks at %ld dhrystones/second\n",
((long) numloops) * HZ / benchtime);
printf(" %ld DMIPS\n",
((long) numloops) * HZ / benchtime / ONE_MIPS);
#endif
#ifdef GETRUSAGE
getrusage(RUSAGE_SELF, &endtime);
{
double t = (double)(endtime.ru_utime.tv_sec
- starttime.ru_utime.tv_sec
- nulltime.tv_sec)
+ (double)(endtime.ru_utime.tv_usec
- starttime.ru_utime.tv_usec
- nulltime.tv_usec) * 1e-6;
printf("Dhrystone(%s) time for %ld passes = %.1f\n",
Version,
(long)numloops,
t);
printf("This machine benchmarks at %.0f dhrystones/second\n",
(double)numloops / t);
printf(" %.0f DMIPS\n",
(double)numloops / t / ONE_MIPS);
}
#endif
}
}
/*
** [ENTRY POINT] does : this is the function called by nginx :
** - Set up the context for the request
** - Check if the job is done and we're called again
** - if it's a PATCH/POST/PUT request, setup hook for body dataz
** - call dummy_data_parse
** - check our context struct (with scores & stuff) against custom check rules
** - check if the request should be denied
*/
static ngx_int_t ngx_http_dummy_access_handler(ngx_http_request_t *r)
{
ngx_http_request_ctx_t *ctx;
ngx_int_t rc;
ngx_http_dummy_loc_conf_t *cf;
struct tms tmsstart, tmsend;
clock_t start, end;
ngx_http_variable_value_t *lookup;
static ngx_str_t learning_flag = ngx_string(RT_LEARNING);
static ngx_str_t enable_flag = ngx_string(RT_ENABLE);
static ngx_str_t post_action_flag = ngx_string(RT_POST_ACTION);
static ngx_str_t extensive_log_flag = ngx_string(RT_EXTENSIVE_LOG);
static ngx_str_t libinjection_sql_flag = ngx_string(RT_LIBINJECTION_SQL);
static ngx_str_t libinjection_xss_flag = ngx_string(RT_LIBINJECTION_XSS);
ctx = ngx_http_get_module_ctx(r, ngx_http_naxsi_module);
cf = ngx_http_get_module_loc_conf(r, ngx_http_naxsi_module);
if (ctx && ctx->over)
return (NGX_DECLINED);
if (ctx && ctx->wait_for_body) {
NX_DEBUG(_debug_mechanics, NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"naxsi:NGX_AGAIN");
return (NGX_DONE);
}
if (!cf)
return (NGX_ERROR);
/* the module is not enabled here */
/* if enable directive is not present at all in the location,
don't try to do dynamic lookup for "live" enabled
naxsi, this would be very rude. */
if (!cf->enabled)
return (NGX_DECLINED);
/* On the other hand, if naxsi has been explicitly disabled
in this location (using naxsi directive), user is probably
trying to do something. */
if (cf->force_disabled) {
/* Look if the user did not try to enable naxsi dynamically */
lookup = ngx_http_get_variable(r, &enable_flag, cf->flag_enable_h);
if (lookup && !lookup->not_found && lookup->len > 0) {
ngx_log_debug(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"live enable is present %d", lookup->data[0] - '0');
if (lookup->data[0] - '0' != 1) {
return (NGX_DECLINED);}
}
else
return (NGX_DECLINED);
}
/* don't process internal requests. */
if (r->internal) {
NX_DEBUG(_debug_mechanics, NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-DON'T PROCESS (%V)|CTX:%p|ARGS:%V|METHOD=%s|INTERNAL:%d", &(r->uri), ctx, &(r->args),
r->method == NGX_HTTP_PATCH ? "PATCH" : r->method == NGX_HTTP_POST ? "POST" : r->method == NGX_HTTP_PUT ? "PUT" : r->method == NGX_HTTP_GET ? "GET" : "UNKNOWN!!",
r->internal);
return (NGX_DECLINED);
}
NX_DEBUG(_debug_mechanics, NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-processing (%V)|CTX:%p|ARGS:%V|METHOD=%s|INTERNAL:%d", &(r->uri), ctx, &(r->args),
r->method == NGX_HTTP_PATCH ? "PATCH" : r->method == NGX_HTTP_POST ? "POST" : r->method == NGX_HTTP_PUT ? "PUT" : r->method == NGX_HTTP_GET ? "GET" : "UNKNOWN!!",
r->internal);
if (!ctx) {
ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_request_ctx_t));
if (ctx == NULL)
return NGX_ERROR;
ngx_http_set_ctx(r, ctx, ngx_http_naxsi_module);
NX_DEBUG(_debug_modifier, NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : orig learning : %d", cf->learning ? 1 : 0);
/* it seems that nginx will - in some cases -
have a variable with empty content but with lookup->not_found set to 0,
so check len as well */
ctx->learning = cf->learning;
lookup = ngx_http_get_variable(r, &learning_flag, cf->flag_learning_h);
if (lookup && !lookup->not_found && lookup->len > 0) {
ctx->learning = lookup->data[0] - '0';
NX_DEBUG(_debug_modifier, NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : override learning : %d (raw=%d)",
ctx->learning ? 1 : 0, lookup->len);
}
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : [final] learning : %d", ctx->learning ? 1 : 0);
ctx->enabled = cf->enabled;
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : orig enabled : %d", ctx->enabled ? 1 : 0);
lookup = ngx_http_get_variable(r, &enable_flag, cf->flag_enable_h);
if (lookup && !lookup->not_found && lookup->len > 0) {
ctx->enabled = lookup->data[0] - '0';
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : override enable : %d", ctx->enabled ? 1 : 0);
}
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : [final] enabled : %d", ctx->enabled ? 1 : 0);
/*
** LIBINJECTION_SQL
*/
ctx->libinjection_sql = cf->libinjection_sql_enabled;
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : orig libinjection_sql : %d", ctx->libinjection_sql ? 1 : 0);
lookup = ngx_http_get_variable(r, &libinjection_sql_flag, cf->flag_libinjection_sql_h);
if (lookup && !lookup->not_found && lookup->len > 0) {
ctx->libinjection_sql = lookup->data[0] - '0';
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : override libinjection_sql : %d", ctx->libinjection_sql ? 1 : 0);
}
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : [final] libinjection_sql : %d", ctx->libinjection_sql ? 1 : 0);
/*
** LIBINJECTION_XSS
*/
ctx->libinjection_xss = cf->libinjection_xss_enabled;
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : orig libinjection_xss : %d", ctx->libinjection_xss ? 1 : 0);
lookup = ngx_http_get_variable(r, &libinjection_xss_flag, cf->flag_libinjection_xss_h);
if (lookup && !lookup->not_found && lookup->len > 0) {
ctx->libinjection_xss = lookup->data[0] - '0';
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : override libinjection_xss : %d", ctx->libinjection_xss ? 1 : 0);
}
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : [final] libinjection_xss : %d", ctx->libinjection_xss ? 1 : 0);
/* post_action is off by default. */
ctx->post_action = 0;
NX_DEBUG( _debug_modifier ,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : orig post_action : %d", ctx->post_action ? 1 : 0);
lookup = ngx_http_get_variable(r, &post_action_flag, cf->flag_post_action_h);
if (lookup && !lookup->not_found && lookup->len > 0) {
ctx->post_action = lookup->data[0] - '0';
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : override post_action : %d", ctx->post_action ? 1 : 0);
}
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : [final] post_action : %d", ctx->post_action ? 1 : 0);
NX_DEBUG( _debug_modifier ,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : orig extensive_log : %d", ctx->extensive_log ? 1 : 0);
lookup = ngx_http_get_variable(r, &extensive_log_flag, cf->flag_extensive_log_h);
if (lookup && !lookup->not_found && lookup->len > 0) {
ctx->extensive_log = lookup->data[0] - '0';
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : override extensive_log : %d", ctx->extensive_log ? 1 : 0);
}
NX_DEBUG( _debug_modifier,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : [final] extensive_log : %d", ctx->extensive_log ? 1 : 0);
/* the module is not enabled here */
if (!ctx->enabled)
return (NGX_DECLINED);
if ((r->method == NGX_HTTP_PATCH || r->method == NGX_HTTP_POST || r->method == NGX_HTTP_PUT)
&& !ctx->ready) {
NX_DEBUG( _debug_mechanics, NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : body_request : before !");
rc = ngx_http_read_client_request_body(r, ngx_http_dummy_payload_handler);
/* this might happen quite often, especially with big files /
** low network speed. our handler is called when headers are read,
** but, often, the full body request hasn't yet, so
** read client request body will return ngx_again. Then we need
** to return ngx_done, wait for our handler to be called once
** body request arrived, and let him call core_run_phases
** to be able to process the request.
*/
if (rc == NGX_AGAIN) {
ctx->wait_for_body = 1;
NX_DEBUG( _debug_mechanics,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : body_request : NGX_AGAIN !");
return (NGX_DONE);
}
else
if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
/*
** might happen but never saw it, let the debug print.
*/
ngx_log_debug(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : SPECIAL RESPONSE !!!!");
return rc;
}
}
else
ctx->ready = 1;
}
if (ctx && ctx->ready && !ctx->over) {
if ((start = times(&tmsstart)) == (clock_t)-1)
ngx_log_debug(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : Failed to get time");
ngx_http_dummy_data_parse(ctx, r);
cf->request_processed++;
if ((end = times(&tmsend)) == (clock_t)-1)
ngx_log_debug(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"XX-dummy : Failed to get time");
if (end - start > 10)
ngx_log_debug(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"[MORE THAN 10MS] times : start:%l end:%l diff:%l",
start, end, (end-start));
ctx->over = 1;
if (ctx->block || ctx->drop) {
cf->request_blocked++;
rc = ngx_http_output_forbidden_page(ctx, r);
//nothing: return (NGX_OK);
//redirect : return (NGX_HTTP_OK);
return rc;
}
else if (ctx->log)
rc = ngx_http_output_forbidden_page(ctx, r);
}
NX_DEBUG(_debug_mechanics,
NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"NGX_FINISHED !");
return NGX_DECLINED;
}
void DynamicResult::prepareCalculations(oRunner &runner) const {
prepareCommon(runner);
pCard pc = runner.getCard();
if (pc) {
vector<pPunch> punches;
pc->getPunches(punches);
int np = 0;
for (size_t k = 0; k < punches.size(); k++) {
if (punches[k]->getTypeCode() >= 30)
np++;
}
vector<int> times(np);
vector<int> codes(np);
vector<int> controls(np);
int ip = 0;
for (size_t k = 0; k < punches.size(); k++) {
if (punches[k]->getTypeCode() >= 30) {
times[ip] = punches[k]->getAdjustedTime();
codes[ip] = punches[k]->getTypeCode();
controls[ip] = punches[k]->isUsedInCourse() ? punches[k]->getControlId() : -1;
ip++;
}
}
parser.addSymbol("CardPunches", codes);
parser.addSymbol("CardTimes", times);
parser.addSymbol("CardControls", controls);
pTeam t = runner.getTeam();
if (t) {
int leg = runner.getLegNumber();
t->setResultCache(oTeam::RCCCardTimes, leg, times);
t->setResultCache(oTeam::RCCCardPunches, leg, codes);
t->setResultCache(oTeam::RCCCardControls, leg, controls);
}
}
else {
vector<int> e;
parser.addSymbol("CardPunches", e);
parser.addSymbol("CardTimes", e);
parser.addSymbol("CardControls", e);
}
pCourse crs = runner.getCourse(true);
const vector<SplitData> &sp = runner.getSplitTimes(false);
if (crs) {
vector<int> eCrs;
vector<int> eSplitTime;
vector<int> eAccTime;
eCrs.reserve(crs->getNumControls());
eSplitTime.reserve(crs->getNumControls());
eAccTime.reserve(crs->getNumControls());
int start = runner.getStartTime();
int st = runner.getStartTime();
for (int k = 0; k < crs->getNumControls(); k++) {
pControl ctrl = crs->getControl(k);
if (ctrl->isSingleStatusOK()) {
eCrs.push_back(ctrl->getFirstNumber());
if (size_t(k) < sp.size()) {
if (sp[k].status == SplitData::OK) {
eAccTime.push_back(sp[k].time-start);
eSplitTime.push_back(sp[k].time-st);
st = sp[k].time;
}
else if (sp[k].status == SplitData::NoTime) {
eAccTime.push_back(st-start);
eSplitTime.push_back(0);
}
else if (sp[k].status == SplitData::Missing) {
eAccTime.push_back(0);
eSplitTime.push_back(-1);
}
}
}
}
if (runner.getFinishTime() > 0) {
eAccTime.push_back(runner.getFinishTime()-start);
eSplitTime.push_back(runner.getFinishTime()-st);
}
else if (!eAccTime.empty()) {
eAccTime.push_back(0);
eSplitTime.push_back(-1);
}
parser.addSymbol("CourseLength", crs->getLength());
parser.addSymbol("Course", eCrs);
parser.addSymbol("SplitTimes", eSplitTime);
parser.addSymbol("SplitTimesAccumulated", eAccTime);
pTeam t = runner.getTeam();
if (t) {
int leg = runner.getLegNumber();
t->setResultCache(oTeam::RCCCourse, leg, eCrs);
t->setResultCache(oTeam::RCCSplitTime, leg, eSplitTime);
}
}
else {
vector<int> e;
parser.addSymbol("CourseLength", -1);
parser.addSymbol("Course", e);
parser.addSymbol("SplitTimes", e);
parser.addSymbol("SplitTimesAccumulated", e);
}
pClass cls = runner.getClassRef();
if (cls) {
int nl = runner.getLegNumber();
parser.addSymbol("ShortestClassTime", cls->getBestLegTime(nl));
}
vector<int> delta;
vector<int> place;
vector<int> after;
runner.getSplitAnalysis(delta);
runner.getLegTimeAfter(after);
runner.getLegPlaces(place);
parser.addSymbol("LegTimeDeviation", delta);
parser.addSymbol("LegTimeAfter", after);
parser.addSymbol("LegPlace", place);
parser.addSymbol("Leg", runner.getLegNumber());
}
int
getrusage(int who, struct rusage * rusage)
{
#ifdef WIN32
FILETIME starttime;
FILETIME exittime;
FILETIME kerneltime;
FILETIME usertime;
ULARGE_INTEGER li;
if (who != RUSAGE_SELF)
{
/* Only RUSAGE_SELF is supported in this implementation for now */
errno = EINVAL;
return -1;
}
if (rusage == (struct rusage *) NULL)
{
errno = EFAULT;
return -1;
}
memset(rusage, 0, sizeof(struct rusage));
if (GetProcessTimes(GetCurrentProcess(),
&starttime, &exittime, &kerneltime, &usertime) == 0)
{
_dosmaperr(GetLastError());
return -1;
}
/* Convert FILETIMEs (0.1 us) to struct timeval */
memcpy(&li, &kerneltime, sizeof(FILETIME));
li.QuadPart /= 10L; /* Convert to microseconds */
rusage->ru_stime.tv_sec = li.QuadPart / 1000000L;
rusage->ru_stime.tv_usec = li.QuadPart % 1000000L;
memcpy(&li, &usertime, sizeof(FILETIME));
li.QuadPart /= 10L; /* Convert to microseconds */
rusage->ru_utime.tv_sec = li.QuadPart / 1000000L;
rusage->ru_utime.tv_usec = li.QuadPart % 1000000L;
#else /* all but WIN32 */
struct tms tms;
int tick_rate = CLK_TCK; /* ticks per second */
clock_t u,
s;
if (rusage == (struct rusage *) NULL)
{
errno = EFAULT;
return -1;
}
if (times(&tms) < 0)
{
/* errno set by times */
return -1;
}
switch (who)
{
case RUSAGE_SELF:
u = tms.tms_utime;
s = tms.tms_stime;
break;
case RUSAGE_CHILDREN:
u = tms.tms_cutime;
s = tms.tms_cstime;
break;
default:
errno = EINVAL;
return -1;
}
#define TICK_TO_SEC(T, RATE) ((T)/(RATE))
#define TICK_TO_USEC(T,RATE) (((T)%(RATE)*1000000)/RATE)
rusage->ru_utime.tv_sec = TICK_TO_SEC(u, tick_rate);
rusage->ru_utime.tv_usec = TICK_TO_USEC(u, tick_rate);
rusage->ru_stime.tv_sec = TICK_TO_SEC(s, tick_rate);
rusage->ru_stime.tv_usec = TICK_TO_USEC(u, tick_rate);
#endif /* WIN32 */
return 0;
}
int main(int argc, char *argv[]) {
GRAPH g;
int countTotal = 0;
boolean writethem = FALSE, printThem = FALSE, printNew = FALSE, printOld = FALSE;
boolean writeOld = FALSE;
boolean first = TRUE;
list = NULL;
int c;
char *name = argv[0];
while ((c = getopt(argc, argv, "hiwnopO")) != -1) {
switch (c) {
case 'h':
help(name);
return EXIT_SUCCESS;
case 'i':
printNew = TRUE;
printOld = TRUE;
break;
case 'n':
printNew = TRUE;
break;
case 'o':
printOld = TRUE;
break;
case 'p':
printThem = TRUE;
break;
case 'w':
writethem = TRUE;
break;
case 'O':
writeOld = TRUE;
break;
default:
usage(name);
return EXIT_FAILURE;
}
}
struct tms TMS;
unsigned int oldtime = 0;
while (read_pg_code(stdin, &g) != EOF) {
countTotal++;
int isNew = handle_new_graph(&g, &list);
if(isNew && writethem) {
write_pg_code(stdout, &g, first);
first = FALSE;
}
if (isNew) {
if(printNew) fprintf(stderr, "Graph %d is new.\n", countTotal);
} else {
if(printOld) fprintf(stderr, "Graph %d is not new.\n", countTotal);
}
if(isNew && printThem) {
printGraph(stderr, &g);
}
if(!isNew && writeOld){
write_pg_code(stdout, &g, first);
first = FALSE;
}
}
int countNonIso = listSize(list);
fprintf(stderr, "Read %d graphs, of which %d pairwise not isomorph.\n", countTotal, countNonIso);
times(&TMS);
unsigned int savetime = oldtime + (unsigned int) TMS.tms_utime;
fprintf(stderr, "CPU time: %.1f seconds.\n", (double) savetime / time_factor);
return (0);
}
// MAIN routine
main( int argc, char **argv ) {
// Elapsed times using <times()>
clock_t clkStart;
clock_t clkStop;
// CPU times for the threads
struct tms tStart;
struct tms tStop;
int k;
int i;
int j;
int temp;
double max;
vFlag = 0;
GetParam( argc, argv );
printf( "Starting timing ... computing ...\n" );
clkStart = times( &tStart );
long threadCounter;
for( threadCounter = 0; threadCounter < M; threadCounter++ ) {
thread_data_arry[ threadCounter ].i = 0;
thread_data_arry[ threadCounter ].b = N;
thread_data_arry[ threadCounter ].thread_id = threadCounter;
printf( "\tmain: creating thread %ld\n", threadCounter );
int threadReturnCode = pthread_create( &idThreads[ threadCounter ], NULL, rowMcol, (void *) &thread_data_arry[ threadCounter ]);
if( threadReturnCode ) {
printf( "ERROR; return code from pthread_create() is %d\n", threadReturnCode );
exit( -1 );
}
}
printf( "\tcompleted thread creation ... going to try to join all threads!\n" );
// for loop processes until all threads terminate
for( threadCounter = 0; threadCounter < M; threadCounter++ ) {
pthread_join( idThreads[ threadCounter ], NULL );
}
printf( "\tall threads have terminated!\n" );
clkStop = times( &tStop );
printf( "Stopped timing.\n" );
if( N < MAXN4print ) {
PrintX();
}
if( vFlag == 1 ) {
CheckX();
}
printf( "Elapsed time = %g ms.\n", (float)( clkStop - clkStart ) / (float) sysconf( _SC_CLK_TCK ) * 1000 );
printf( "The total CPU time comsumed = %g ms.\n", (float)(( tStop.tms_utime - tStart.tms_utime ) + ( tStop.tms_stime - tStart.tms_stime )) / (float)sysconf( _SC_CLK_TCK ) * 1000 );
// Last thing that main() should do
pthread_exit( NULL );
return 0;
}
void start_clock(Statistics *stat)
{
stat->start_time = times(&stat->start_cpu);
}
int main(void)
{
struct itimerval it;
struct tms buf;
clock_t clk_tck, start_real, start_virtual, end_real, end_virtual;
unsigned long count;
void *data;
int size;
char *setting1, *setting2;
int i;
#ifdef TEST_THREADS
pthread_t t[TEST_THREADS];
void *t_retval;
#endif
data = NULL;
size = 0x12345678;
for (i = 0; tests[i][0]; i++) {
const char *hash = tests[i][0];
const char *key = tests[i][1];
const char *setting = tests[i][2];
const char *p;
int ok = !setting || strlen(hash) >= 30;
int o_size;
char s_buf[30], o_buf[61];
if (!setting) {
memcpy(s_buf, hash, sizeof(s_buf) - 1);
s_buf[sizeof(s_buf) - 1] = 0;
setting = s_buf;
}
__set_errno(0);
p = crypt(key, setting);
if ((!ok && !errno) || strcmp(p, hash)) {
printf("FAILED (crypt/%d)\n", i);
return 1;
}
if (ok && strcmp(crypt(key, hash), hash)) {
printf("FAILED (crypt/%d)\n", i);
return 1;
}
for (o_size = -1; o_size <= (int)sizeof(o_buf); o_size++) {
int ok_n = ok && o_size == (int)sizeof(o_buf);
const char *x = "abc";
strcpy(o_buf, x);
if (o_size >= 3) {
x = "*0";
if (setting[0] == '*' && setting[1] == '0')
x = "*1";
}
__set_errno(0);
p = crypt_rn(key, setting, o_buf, o_size);
if ((ok_n && (!p || strcmp(p, hash))) ||
(!ok_n && (!errno || p || strcmp(o_buf, x)))) {
printf("FAILED (crypt_rn/%d)\n", i);
return 1;
}
}
__set_errno(0);
p = crypt_ra(key, setting, &data, &size);
if ((ok && (!p || strcmp(p, hash))) ||
(!ok && (!errno || p || strcmp((char *)data, hash)))) {
printf("FAILED (crypt_ra/%d)\n", i);
return 1;
}
}
setting1 = crypt_gensalt(which[0], 12, data, size);
if (!setting1 || strncmp(setting1, "$2a$12$", 7)) {
puts("FAILED (crypt_gensalt)\n");
return 1;
}
setting2 = crypt_gensalt_ra(setting1, 12, data, size);
if (strcmp(setting1, setting2)) {
puts("FAILED (crypt_gensalt_ra/1)\n");
return 1;
}
(*(char *)data)++;
setting1 = crypt_gensalt_ra(setting2, 12, data, size);
if (!strcmp(setting1, setting2)) {
puts("FAILED (crypt_gensalt_ra/2)\n");
return 1;
}
free(setting1);
free(setting2);
free(data);
#if defined(_SC_CLK_TCK) || !defined(CLK_TCK)
clk_tck = sysconf(_SC_CLK_TCK);
#else
clk_tck = CLK_TCK;
#endif
running = 1;
signal(SIGALRM, handle_timer);
memset(&it, 0, sizeof(it));
it.it_value.tv_sec = 5;
setitimer(ITIMER_REAL, &it, NULL);
start_real = times(&buf);
start_virtual = buf.tms_utime + buf.tms_stime;
count = (char *)run((char *)0) - (char *)0;
end_real = times(&buf);
end_virtual = buf.tms_utime + buf.tms_stime;
if (end_virtual == start_virtual) end_virtual++;
printf("%.1f c/s real, %.1f c/s virtual\n",
(float)count * clk_tck / (end_real - start_real),
(float)count * clk_tck / (end_virtual - start_virtual));
#ifdef TEST_THREADS
running = 1;
it.it_value.tv_sec = 60;
setitimer(ITIMER_REAL, &it, NULL);
start_real = times(&buf);
for (i = 0; i < TEST_THREADS; i++)
if (pthread_create(&t[i], NULL, run, i + (char *)0)) {
perror("pthread_create");
return 1;
}
for (i = 0; i < TEST_THREADS; i++) {
if (pthread_join(t[i], &t_retval)) {
perror("pthread_join");
continue;
}
if (!t_retval) continue;
count = (char *)t_retval - (char *)0;
end_real = times(&buf);
printf("%d: %.1f c/s real\n", i,
(float)count * clk_tck / (end_real - start_real));
}
#endif
return 0;
}
Foam::word Foam::Time::findInstance
(
const fileName& dir,
const word& name,
const IOobject::readOption rOpt,
const word& stopInstance
) const
{
// Note: if name is empty, just check the directory itself
// check the current time directory
if
(
name.empty()
? isDir(path()/timeName()/dir)
:
(
isFile(path()/timeName()/dir/name)
&& IOobject(name, timeName(), dir, *this).headerOk()
)
)
{
if (debug)
{
Info<< "Time::findInstance"
"(const fileName&, const word&, const IOobject::readOption)"
<< " : found \"" << name
<< "\" in " << timeName()/dir
<< endl;
}
return timeName();
}
// Search back through the time directories to find the time
// closest to and lower than current time
instantList ts = times();
label instanceI;
for (instanceI = ts.size()-1; instanceI >= 0; --instanceI)
{
if (ts[instanceI].value() <= timeOutputValue())
{
break;
}
}
// continue searching from here
for (; instanceI >= 0; --instanceI)
{
if
(
name.empty()
? isDir(path()/ts[instanceI].name()/dir)
:
(
isFile(path()/ts[instanceI].name()/dir/name)
&& IOobject(name, ts[instanceI].name(), dir, *this).headerOk()
)
)
{
if (debug)
{
Info<< "Time::findInstance"
"(const fileName&, const word&, const IOobject::readOption)"
<< " : found \"" << name
<< "\" in " << ts[instanceI].name()/dir
<< endl;
}
return ts[instanceI].name();
}
// Check if hit minimum instance
if (ts[instanceI].name() == stopInstance)
{
if (debug)
{
Info<< "Time::findInstance"
"(const fileName&, const word&"
", const IOobject::readOption, const word&)"
<< " : hit stopInstance " << stopInstance
<< endl;
}
if (rOpt == IOobject::MUST_READ)
{
FatalErrorIn
(
"Time::findInstance"
"(const fileName&, const word&"
", const IOobject::readOption, const word&)"
) << "Cannot find file \"" << name << "\" in directory "
<< dir << " in times " << timeName()
<< " down to " << stopInstance
<< exit(FatalError);
}
return ts[instanceI].name();
}
}
// not in any of the time directories, try constant
// Note. This needs to be a hard-coded constant, rather than the
// constant function of the time, because the latter points to
// the case constant directory in parallel cases
if
(
name.empty()
? isDir(path()/constant()/dir)
:
(
isFile(path()/constant()/dir/name)
&& IOobject(name, constant(), dir, *this).headerOk()
)
)
{
if (debug)
{
Info<< "Time::findInstance"
"(const fileName&, const word&, const IOobject::readOption)"
<< " : found \"" << name
<< "\" in " << constant()/dir
<< endl;
}
return constant();
}
if (rOpt == IOobject::MUST_READ)
{
FatalErrorIn
(
"Time::findInstance"
"(const fileName&, const word&, const IOobject::readOption)"
) << "Cannot find file \"" << name << "\" in directory "
<< dir << " in times " << timeName()
<< " down to " << constant()
<< exit(FatalError);
}
return constant();
}
int
connect_nonb(int sockfd, const struct sockaddr *saptr, socklen_t salen, int nsec)
{
int flags, n, conn_error;
socklen_t len;
fd_set rset, wset;
struct timeval tval;
flags = fcntl(sockfd, F_GETFL, 0);
if ( flags == -1 ) {
error("fcntl: %s", strerror(errno));
return FAIL;
}
n = fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
if ( n == -1 ) {
error("fcntl: %s", strerror(errno));
return FAIL;
}
conn_error = 0;
if ( (n = connect(sockfd, saptr, salen)) < 0 )
#ifdef AIX5
if (!(errno == EINPROGRESS || errno == EEXIST || errno == 17)) {
#else
if (errno != EINPROGRESS) {
#endif
error("connect: %s", strerror(errno));
return FAIL;
}
/* connect(2) is under progress */
if ( n == 0 ) goto done; /* connect(2) completed immediately */
FD_ZERO(&rset);
FD_SET(sockfd, &rset);
wset = rset;
tval.tv_sec = nsec;
tval.tv_usec = 0;
if ( (n = select(sockfd + 1, &rset, &wset, NULL,
nsec ? &tval : NULL)) == 0 ) {
close(sockfd);
warn("select timedout(timeout = %d)", nsec);
errno = ETIMEDOUT;
return FAIL;
} else if ( n == -1 ) {
error("select: %s", strerror(errno));
return FAIL;
}
if (FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset)) {
len = sizeof(conn_error);
// refer to connect(2) EINPROGRESS error part
if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &conn_error, &len) < 0) {
error("getsockopt: %s", strerror(errno));
return FAIL;
}
} else {
error("select: sockfd not set");
return FAIL;
}
done:
n = fcntl(sockfd, F_SETFL, flags); /* restore file status flags */
if ( n == -1 ) {
error("fcntl: %s", strerror(errno));
return FAIL;
}
if (conn_error) {
close(sockfd);
errno = conn_error;
error("%s", strerror(errno));
return FAIL;
}
return SUCCESS;
}
/*****************************************************************************/
int sb_tstat_start(tstat_t *tstat) {
if ((tstat->cs = times(&(tstat->tms_s))) == (clock_t)-1) {
error("%s", strerror(errno));
return -1;
}
if (gettimeofday(&(tstat->tv_s), NULL) == -1) {
error("%s", strerror(errno));
return -1;
}
return 1;
}
int sb_tstat_finish(tstat_t *tstat) {
if ((tstat->cf = times(&(tstat->tms_f))) == (clock_t)-1) {
error("%s", strerror(errno));
return -1;
}
if (gettimeofday(&(tstat->tv_f), NULL) == -1) {
error("%s", strerror(errno));
return -1;
}
return 1;
}
void sb_tstat_print(tstat_t *tstat) {
clock_t clock_per_second;
/* printf("gauged by gettimeofday(): Realtime:%d(ms)", */
/* (tstat->tv_f.tv_sec - tstat->tv_s.tv_sec)*1000 +*/
/* (tstat->tv_f.tv_usec - tstat->tv_s.tv_usec)/1000);*/
info("gauged by gettimeofday(): Realtime:%d(s)",
(int)(tstat->tv_f.tv_sec - tstat->tv_s.tv_sec));
clock_per_second = sysconf(_SC_CLK_TCK);
info("gauged by times(): Realtime:%.2f(s), User Time %.2f(s), System Time %.2f(s)\n",
(float)(tstat->cf - tstat->cs) / clock_per_second,
(float)(tstat->tms_f.tms_utime - tstat->tms_s.tms_utime) / clock_per_second,
(float)(tstat->tms_f.tms_stime - tstat->tms_s.tms_stime) / clock_per_second);
}
int main(int argc,char** argv)
{
int i,j,fd;
int n=0;
char buffer[100];
int closed=0;
int numsplitters=atoi(argv[2]);
int id=atoi(argv[1]);
builder_List lista=builder_create_list();
char*pipe_name;
double t1, t2, cpu_time;
struct tms tb1, tb2;
double ticspersec;
int sum = 0;
ticspersec = (double) sysconf(_SC_CLK_TCK);
t1 = (double) times(&tb1);
struct pollfd pfds[numsplitters];
for (i=0;i<numsplitters;i++){
pipe_name=name_of_pipe(i,id);
pfds[i].fd =open(pipe_name, O_RDONLY);
pfds[i].events = POLLIN;
}
printf("perasa tin loopa twn splitter\n");
int k=0;
while(closed<numsplitters){
int num = poll(pfds, numsplitters, -1);
int ar=0;
if(num != 0)
{
if (num == -1)
{
perror("poll");
exit(1);
}
for(j = 0; j < numsplitters; j++)
{
if(pfds[j].revents & POLLIN)
{
if(read_data (pfds[j].fd ,buffer)>0){
ar++;
if (strcmp(buffer,"oulala")==0){
closed++;
}
else{
if(builder_search_list(lista,buffer)!=1)
builder_insert_to_end(lista,builder_create_node(buffer));
} }
}
}
}
}
// teleiwse to diavasma apo tous splitters twra stelnw sto root
pipe_name=name_of_pipe(-1,id);
send_all(lista,pipe_name);
printf("builder %d closed \n",id);
t2 = (double) times(&tb2);
cpu_time = (double) ((tb2.tms_utime + tb2.tms_stime) -
(tb1.tms_utime + tb1.tms_stime));
//printf("Run time was %lf sec (REAL time) although we used the CPU for %lf sec (CPU time).\n",(t2 - t1)/ticspersec,cpu_time/ticspersec);
free(pipe_name);
FILE * fpa;
fpa = fopen (argv[3], "a");
fprintf(fpa,"BUILDER %d : (REAL time) %lf sec (CPU time) %lf sec \n",id,(t2 - t1)/ticspersec,cpu_time/ticspersec);
//sleep(3);
fclose(fpa);
kill(getppid(),SIGRTMIN+2);
kill(getppid(),SIGUSR2);
}
static PyObject*
py_process_time(_Py_clock_info_t *info)
{
#if defined(MS_WINDOWS)
HANDLE process;
FILETIME creation_time, exit_time, kernel_time, user_time;
ULARGE_INTEGER large;
double total;
BOOL ok;
process = GetCurrentProcess();
ok = GetProcessTimes(process, &creation_time, &exit_time, &kernel_time, &user_time);
if (!ok)
return PyErr_SetFromWindowsErr(0);
large.u.LowPart = kernel_time.dwLowDateTime;
large.u.HighPart = kernel_time.dwHighDateTime;
total = (double)large.QuadPart;
large.u.LowPart = user_time.dwLowDateTime;
large.u.HighPart = user_time.dwHighDateTime;
total += (double)large.QuadPart;
if (info) {
info->implementation = "GetProcessTimes()";
info->resolution = 1e-7;
info->monotonic = 1;
info->adjustable = 0;
}
return PyFloat_FromDouble(total * 1e-7);
#else
#if defined(HAVE_SYS_RESOURCE_H)
struct rusage ru;
#endif
#ifdef HAVE_TIMES
struct tms t;
static long ticks_per_second = -1;
#endif
#if defined(HAVE_CLOCK_GETTIME) \
&& (defined(CLOCK_PROCESS_CPUTIME_ID) || defined(CLOCK_PROF))
struct timespec tp;
#ifdef CLOCK_PROF
const clockid_t clk_id = CLOCK_PROF;
const char *function = "clock_gettime(CLOCK_PROF)";
#else
const clockid_t clk_id = CLOCK_PROCESS_CPUTIME_ID;
const char *function = "clock_gettime(CLOCK_PROCESS_CPUTIME_ID)";
#endif
if (clock_gettime(clk_id, &tp) == 0) {
if (info) {
struct timespec res;
info->implementation = function;
info->monotonic = 1;
info->adjustable = 0;
if (clock_getres(clk_id, &res) == 0)
info->resolution = res.tv_sec + res.tv_nsec * 1e-9;
else
info->resolution = 1e-9;
}
return PyFloat_FromDouble(tp.tv_sec + tp.tv_nsec * 1e-9);
}
#endif
#if defined(HAVE_SYS_RESOURCE_H)
if (getrusage(RUSAGE_SELF, &ru) == 0) {
double total;
total = ru.ru_utime.tv_sec + ru.ru_utime.tv_usec * 1e-6;
total += ru.ru_stime.tv_sec + ru.ru_stime.tv_usec * 1e-6;
if (info) {
info->implementation = "getrusage(RUSAGE_SELF)";
info->monotonic = 1;
info->adjustable = 0;
info->resolution = 1e-6;
}
return PyFloat_FromDouble(total);
}
#endif
#ifdef HAVE_TIMES
if (times(&t) != (clock_t)-1) {
double total;
if (ticks_per_second == -1) {
#if defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)
ticks_per_second = sysconf(_SC_CLK_TCK);
if (ticks_per_second < 1)
ticks_per_second = -1;
#elif defined(HZ)
ticks_per_second = HZ;
#else
ticks_per_second = 60; /* magic fallback value; may be bogus */
#endif
}
if (ticks_per_second != -1) {
total = (double)t.tms_utime / ticks_per_second;
total += (double)t.tms_stime / ticks_per_second;
if (info) {
info->implementation = "times()";
info->monotonic = 1;
info->adjustable = 0;
info->resolution = 1.0 / ticks_per_second;
}
return PyFloat_FromDouble(total);
}
}
#endif
return floatclock(info);
#endif
}
int
endnote(int xno)
{
struct timeval tp;
struct timezone tzp;
int i,j,final_bytes,fno;
float notepeak,*pk;
double total;
long *pkloc;
struct tms timbuf;
float peakval;
struct stat st;
short tisamp,*tibuf;
float tfsamp,*tfbuf;
fno = ABS(xno); /* if fno is negative it means don't write
final buffer,just pretend to */
if(wipe_is_off[fno])
_backup(fno);
/* else _flushbuf(fno); */
if(!peakoff[fno]) _chkpeak(fno);
final_bytes = pointer[fno] * sfclass(&sfdesc[fno]);
/* This was DS's and PL's version of real time */
/* Not used in this version */
#ifdef OLDRT
/* SHOULD NOT PLAY HERE -- LAST BUFFERS ALREADY PLAYED */
if ((sfclass(&sfdesc[fno]) == SF_SHORT) && play_is_on)
playbuf(sndbuf[fno],final_bytes/SF_SHORT);
else if ((sfclass(&sfdesc[fno]) == SF_FLOAT) && play_is_on) {
peakval = getpeakval(peakflag,fno);
playfbuf(sndbuf[fno],peakval,swap[fno],nbytes/SF_FLOAT);
}
#endif
/* write out only fractional part of last record, god bless unix!*/
if(pointer[fno] && (play_is_on < 2)) {
if(xno >= 0) {
/* Swap bytes if necessary */
if(final_bytes && swap_bytes[fno]) {
/* SHORT file */
if(sfclass(&sfdesc[fno]) == SF_SHORT) {
tibuf = (short *)sndbuf[fno];
for (i=0;i<final_bytes/SF_SHORT;i++) {
tisamp = *(tibuf+i);
*(tibuf+i) = reverse_int2(&tisamp);
}
}
/* FLOAT file */
if(sfclass(&sfdesc[fno]) == SF_FLOAT) {
tfbuf = (float *)sndbuf[fno];
for (i=0;i<final_bytes/SF_FLOAT;i++) {
/* byte_reverse4(tfbuf+i); */
/* tfsamp = *(tfbuf+i); */
/* *(tfbuf+i) = (float)reverse_int4(&tfsamp); */
tfsamp = *(tfbuf+i);
byte_reverse4(&tfsamp);
*(tfbuf+i) = tfsamp;
}
}
}
if((i = write(sfd[fno],sndbuf[fno],final_bytes))
!= final_bytes) {
fprintf(stderr,
"CMIX: Bad UNIX write, file %d, nbytes = %d\n",
fno,i);
perror("write");
closesf();
}
}
if((filepointer[fno] += final_bytes) > originalsize[fno])
if(xno >0) originalsize[fno] = filepointer[fno];
}
/* DT: if(play_is_on) flush_buffers(); */
pk = (float *)peak[fno];
pkloc = (long *)peakloc[fno];
total = ((double)filepointer[fno]-headersize[fno])
/((double)sfclass(&sfdesc[fno]))
/(double)sfchans(&sfdesc[fno])/SR();
/* _writeit(fno); write out final record */
for(i = 0,notepeak=0; i<sfchans(&sfdesc[fno]); i++) {
if(*(pk+i) > sfmaxamp(&sfm[fno],i)) {
sfmaxamp(&sfm[fno],i) = *(pk+i);
sfmaxamploc(&sfm[fno],i) = *(pkloc+i);
}
if(*(pk+i) > notepeak) notepeak = *(pk+i);
}
gettimeofday(&tp,&tzp);
sfmaxamptime(&sfm[fno]) = tp.tv_sec;
if((filepointer[fno] = lseek(sfd[fno],0L,0)) < 0) {
fprintf(stderr,"Bad lseek to beginning of file\n");
perror("lseek");
closesf();
}
times(&timbuf);
printf("\n(%6.2f)",(float)(
(timbuf.tms_stime-clockin[fno].tms_stime)+
(timbuf.tms_utime-clockin[fno].tms_utime))/60.);
printf(" %9.4f .. %9.4f MM ",starttime[fno],total);
if(!peakoff[fno]) {
for(j=0;j<sfchans(&sfdesc[fno]);j++)
printf(" c%d=%e",j,*(pk+j));
printf("\n");
if(punch[fno]) {
printf("alter(%e,%e,%e/%e",
(double)starttime[fno],(double)(total-starttime[fno]),
punch[fno],notepeak);
for(i=0; i<sfchans(&sfdesc[fno]); i++)
printf(",1 ");
printf(")\n");
printf("mix(%g,%g,%g,%g/%g",
(double)starttime[fno],(double)starttime[fno],-(double)(total-starttime[fno]),punch[fno],notepeak);
for(i=0; i<sfchans(&sfdesc[fno]); i++)
printf(",%d ",i);
printf(")\n");
}
}
/* Copy the updated peak stats into the SFHEADER struct for this
output file. (No swapping necessary.)
*/
memcpy(&(sfmaxampstruct(&sfdesc[fno])), &sfm[fno], sizeof(SFMAXAMP));
/* Write header to file. */
if (wheader(sfd[fno], &sfdesc[fno])) {
fprintf(stderr, "endnote: bad header write\n");
perror("write");
closesf();
}
return 0;
}
/*
* get_tmp_disk - Return the total size of temporary file system on
* this system
* Input: tmp_disk - buffer for the disk space size
* tmp_fs - pathname of the temporary file system to status,
* defaults to "/tmp"
* Output: tmp_disk - filled in with disk space size in MB, zero if error
* return code - 0 if no error, otherwise errno
*/
extern int
get_tmp_disk(uint32_t *tmp_disk, char *tmp_fs)
{
int error_code = 0;
#ifdef HAVE_SYS_VFS_H
struct statfs stat_buf;
long total_size;
float page_size;
char *tmp_fs_name = tmp_fs;
*tmp_disk = 0;
total_size = 0;
page_size = (sysconf(_SC_PAGE_SIZE) / 1048576.0); /* MG per page */
if (tmp_fs_name == NULL)
tmp_fs_name = "/tmp";
#if defined (__sun)
if (statfs(tmp_fs_name, &stat_buf, 0, 0) == 0) {
#else
if (statfs(tmp_fs_name, &stat_buf) == 0) {
#endif
total_size = (long)stat_buf.f_blocks;
}
else if (errno != ENOENT) {
error_code = errno;
error ("get_tmp_disk: error %d executing statfs on %s",
errno, tmp_fs_name);
}
*tmp_disk += (uint32_t)(total_size * page_size);
#else
*tmp_disk = 1;
#endif
return error_code;
}
extern int get_up_time(uint32_t *up_time)
{
#if defined(HAVE_AIX) || defined(__sun) || defined(__APPLE__)
clock_t tm;
struct tms buf;
tm = times(&buf);
if (tm == (clock_t) -1) {
*up_time = 0;
return errno;
}
*up_time = tm / sysconf(_SC_CLK_TCK);
#elif defined(__CYGWIN__)
FILE *uptime_file;
char buffer[128];
char* _uptime_path = "/proc/uptime";
if (!(uptime_file = fopen(_uptime_path, "r"))) {
error("get_up_time: error %d opening %s", errno, _uptime_path);
return errno;
}
if (fgets(buffer, sizeof(buffer), uptime_file))
*up_time = atoi(buffer);
fclose(uptime_file);
#else
/* NOTE for Linux: The return value of times() may overflow the
* possible range of type clock_t. There is also an offset of
* 429 million seconds on some implementations. We just use the
* simpler sysinfo() function instead. */
struct sysinfo info;
if (sysinfo(&info) < 0) {
*up_time = 0;
return errno;
}
*up_time = info.uptime;
#endif
return 0;
}
/*
* It would be -so- nice just to call _wait4 and mapstatus here.
*/
int
wait4(int pid, int *status, int options, struct rusage *rp)
{
struct tms before_tms;
struct tms after_tms;
siginfo_t info;
int error;
int noptions;
idtype_t idtype;
if ((int)status == -1 || (int)rp == -1) {
errno = EFAULT;
return(-1);
}
if (rp)
memset(rp, 0, sizeof(struct rusage));
memset(&info, 0, sizeof (siginfo_t));
if (times(&before_tms) < 0)
return (-1); /* errno is set by times() */
/*
* BSD's wait* routines only support WNOHANG & WUNTRACED
*/
if (options & ~(WNOHANG|WUNTRACED))
return (EINVAL);
noptions = N_WEXITED | N_WTRAPPED;
if (options & WNOHANG)
noptions |= N_WNOHANG;
if (options & WUNTRACED)
noptions |= N_WUNTRACED; /* == N_WSTOPPED */
/*
* Emulate undocumented 4.x semantics for 1186845
*/
if (pid < 0) {
pid = -pid;
idtype = P_PGID;
} else if (pid == 0)
idtype = P_ALL;
else
idtype = P_PID;
error = _waitid(idtype, pid, &info, noptions);
if (error == 0) {
long diffu; /* difference in usertime (ticks) */
long diffs; /* difference in systemtime (ticks) */
if ((options & WNOHANG) && (info.si_pid == 0))
return (0); /* no child found */
if (rp) {
if (times(&after_tms) < 0)
return (-1); /* errno already set by times() */
/*
* The system/user time is an approximation only !!!
*/
diffu = after_tms.tms_cutime - before_tms.tms_cutime;
diffs = after_tms.tms_cstime - before_tms.tms_cstime;
rp->ru_utime.tv_sec = diffu / HZ;
rp->ru_utime.tv_usec = (diffu % HZ) * (1000000 / HZ);
rp->ru_stime.tv_sec = diffs / HZ;
rp->ru_stime.tv_usec = (diffs % HZ) * (1000000 / HZ);
}
if (status)
*status = wstat(info.si_code, info.si_status);
return (info.si_pid);
} else {
return (-1); /* error number is set by waitid() */
}
}
typedef struct
{
unsigned long UID;
tPvHandle Handle;
tPvFrame Frames[FRAMESCOUNT];
bool Abort;
} tCamera;
// global camera data
tCamera GCamera;
#if defined(_LINUX) || defined(_QNX) || defined(_OSX)
struct tms gTMS;
unsigned long gT00 = times(&gTMS);
void Sleep(unsigned int time)
{
struct timespec t,r;
t.tv_sec = time / 1000;
t.tv_nsec = (time % 1000) * 1000000;
while(nanosleep(&t,&r)==-1)
t = r;
}
void SetConsoleCtrlHandler(void (*func)(int), int junk)
{
signal(SIGINT, func);
int main(int argc, char *argv[]) {
struct tms usage;
FILE *finp;
int i,j, ticks;
int numinfirst;
char chkfile[255];
i=0;
dump_file=NULL;
do_cluster=do_pairwise_cluster;
srandom(563573);
bzero(&prog_opts,sizeof(ProgOptionsType));
outf=stdout;
// set default distance function
dist = d2;
distpair= d2pair;
#ifdef MPI
MPI_Init(&argc, &argv);
MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
#endif
if(myid==0) { // Master
process_options(argc, argv);
} else {
process_slave_options(argc, argv);
}
if (prog_opts.show_version || (argc==1)) {
if (myid==0) printf("Version \n%s\n",version);
#ifdef MPI
MPI_Finalize();
#endif
exit(0);
}
// Allocate space for the RC table for big words
rc_big = calloc(BIG_WORD_TSIZE, sizeof(SeqElt));
// work is an array of work blocks. If non-parallel, there'll only
// be one. work[0] acts a template
work = (WorkPtr) calloc(num_threads,sizeof(WorkBlock));
work->filename = argv[optind];
work->index = NULL;
if(prog_opts.do_dump) dump_file = fopen(prog_opts.dname,"w");
#ifdef MPI
if (numprocs > 1)
if (myid>0) { // slaves
if (prog_opts.split) {
MPI_Finalize();
return 0;
}
handleMPISlaveSetup(&num_seqs);
initialise(work, prog_opts.edfile);
internalTest();
perform_clustering(work);
transmitMPISlaveResponse(work);
if (prog_opts.show_perf) show_performance(outf);
MPI_Finalize();
exit(0);
}
#else
if (numprocs > 1) {
printf("This version of wcd is not compiled with MPI\n");
printf("You cannot run it with a multiple processes\n");
printf("Either only run it with one process or do a \n");
printf(" ./configure --enable-mpi\n");
printf(" make clean\n");
printf(" make \n");
exit(5);
}
#endif
// work out number of sequences
// if the user has specified a value for num_seqs then
// use that, else use the number of sequences in the file
num_seqs = count_seqs(argv[optind], &data_size)+reindex_value;
seq = (SeqPtr *) calloc(num_seqs,sizeof(SeqPtr));
seqInfo = (SeqInfoPtr) calloc(num_seqs,sizeof(SeqInfoStruct));
tree= (UnionFindPtr) calloc(num_seqs,sizeof(UnionFindStruct));
data= (SeqPtr) calloc(data_size,sizeof(SeqElt));
init_dummy_sequences();
#ifndef AUXINFO
seqID = (SeqIDPtr) calloc(num_seqs,sizeof(SeqIDStruct));
#endif
if (seq == NULL) {
perror("SeqStruct allocation");
exit(50);
}
numinfirst = global_i_end = num_seqs;
global_j_beg = 0;
// if merging, need to check the other file too
if (prog_opts.domerge || prog_opts.doadd ) {
global_j_beg = global_i_end;
num_seqs = handleMerge(argv[optind+2], num_seqs);
if (prog_opts.doadd) global_i_end = num_seqs;
}
initialise(work, prog_opts.edfile);
if (data == NULL) {
sprintf(chkfile,"Main data store (%d bytes)",data_size);
perror(chkfile);
exit(51);
}
for(i=0; i<num_seqs; i++) seqInfo[i].flag=0;
// reopen sequence file for reading
finp = fopen(argv[optind],"r");
if (finp == NULL) {
perror(argv[optind]);
exit(51);
}
// Some messy stuff to hande auxiliary options
// Skip to next comment on first reading
if (prog_opts.pairwise==1) {
sscanf(argv[optind+1], "%d", &i);
sscanf(argv[optind+2], "%d", &j);
show_pairwise(finp,i,j);
return 0;
}
if (prog_opts.statgen) {
compared2nummatches(finp,prog_opts.statgen);
return 0;
}
if (prog_opts.range) {
sscanf(argv[optind+1], "%d", &global_i_beg);
sscanf(argv[optind+2], "%d", &global_i_end);
}
if (prog_opts.show_comp==41) {
char * fname; fname = malloc(255);
sscanf(argv[optind+1], "%s", fname);
read_sequences(finp,reindex_value,num_seqs);
checkfile = fopen(fname,"r");
sscanf(argv[optind+2], "%d", &j);
while (fscanf(checkfile,"%d", &i) != -1) {
do_compare(finp,i,j,1);
}
return 0;
}
if (prog_opts.show_comp) {
sscanf(argv[optind+1], "%d", &i);
sscanf(argv[optind+2], "%d", &j);
//printf("Comparing %d and %d of %d flag %d\n",i,j,num_seqs,prog_opts.flag);
read_sequences(finp,reindex_value,num_seqs);
do_compare(finp,i,j,prog_opts.flag);
return 0;
}
if (prog_opts.show_index) {
show_sequence(finp, prog_opts.index,prog_opts.flag);
return 0;
}
// Now read in the sequences
if (do_cluster == do_pairwise_cluster||do_cluster==do_MPImaster_cluster||do_cluster == do_suffix_cluster)
read_sequences(finp,reindex_value,numinfirst);
else
init_sequences(finp,reindex_value,numinfirst);
fclose(finp);
//printf("%d Allocated %d, start=%d, last=%d\n",num_seqs,data_size,data,seq[num_seqs-1].seq);
if (prog_opts.split) {
process_split(prog_opts.clfname1, prog_opts.split);
#ifdef MPI
MPI_Finalize();
#endif
return 0;
}
if (prog_opts.consfname1) process_constraints(prog_opts.consfname1,0);
if (prog_opts.clustercomp) {
cluster_compare(argv[optind+1]);
return 0;
}
// If merging or adding need to open the second sequence file
if (prog_opts.domerge || prog_opts.doadd) {
finp = fopen(argv[optind+2], "r");
if (finp == NULL) {
perror(argv[optind]);
exit(1);
}
if (do_cluster == do_pairwise_cluster)
read_sequences(finp,numinfirst+reindex_value,num_seqs);
else
init_sequences(finp,numinfirst+reindex_value,num_seqs);
get_clustering(argv[optind+1],0);
if (prog_opts.domerge) get_clustering(argv[optind+3],numinfirst);
}
if (prog_opts.init_cluster) get_clustering(prog_opts.clfname1, 0);
if (prog_opts.recluster)
reclustering(work,prog_opts.clfname2);
else {
// This really assumes there is only one thread for suffix
if (prog_opts.pairwise==2) {
matrix_compare(finp);
return 0;
}
work->workflag = prog_opts.noninterleavednlc;//kludge for suffixarray
global_j_end = num_seqs;
perform_clustering(work);
#ifdef MPI
if (myid>0) transmitMPISlaveResponse(work);
#endif
}
if (prog_opts.show_ext) show_EXT(outf);
if (prog_opts.show_histo) show_histogram(work);
if (prog_opts.show_clust&1) show_clusters(outf);
if (prog_opts.show_clust&8)
produce_clusters(prog_opts.clthresh,prog_opts.dirname);
if (prog_opts.show_perf) show_performance(outf);
if (prog_opts.do_dump) {
strcpy(chkfile,prog_opts.dname);
strcat(chkfile,"-FIN");
fclose(dump_file);
dump_file = fopen(chkfile,"w");
times(&usage);
ticks = sysconf(_SC_CLK_TCK);
fprintf(dump_file,"Completed %ld %ld", usage.tms_utime/ticks, usage.tms_stime*1000/ticks);
fclose(dump_file);
}
if (prog_opts.show_version) fprintf(outf,"\n%s\n",version);
fclose(outf);
#ifdef MPI
MPI_Finalize();
#endif
exit(0);
}
std::vector<int> ParameterFileSimple::getTimes() const {
std::vector<int> times(1,0);
return times;
}
int main(int argc, char*argv[])
{
char *tcp_device;
int fd, i;
struct svrqueryparam qpar;
char *pval;
struct timeval uptime;
clock_t now;
int fl;
int a_flag, n_flag, v_flag;
(prog_name=strrchr(argv[0], '/')) ? prog_name++ : (prog_name=argv[0]);
a_flag= 0;
n_flag= 0;
v_flag= 0;
while ((fl= getopt(argc, argv, "?anv")) != -1)
{
switch(fl)
{
case '?':
usage();
case 'a':
a_flag= 1;
break;
case 'n':
n_flag= 1;
break;
case 'v':
v_flag= 1;
break;
default:
fprintf(stderr, "%s: getopt failed: '%c'\n",
prog_name, fl);
exit(1);
}
}
inclListen= !!a_flag;
numerical= !!n_flag;
verbose= !!v_flag;
tcp_device= TCP_DEVICE;
if ((fd= open(tcp_device, O_RDWR)) == -1)
{
fprintf(stderr, "%s: unable to open '%s': %s\n", prog_name,
tcp_device, strerror(errno));
exit(1);
}
qpar.param = "tcp_conn_table";
qpar.psize = strlen(qpar.param);
qpar.value = values;
qpar.vsize = sizeof(values);
if (ioctl(fd, NWIOQUERYPARAM, &qpar) == -1)
{
fprintf(stderr, "%s: queryparam failed: %s\n", prog_name,
strerror(errno));
exit(1);
}
pval= values;
if (paramvalue(&pval, tcp_conn_table, sizeof(tcp_conn_table)) !=
sizeof(tcp_conn_table))
{
fprintf(stderr,
"%s: unable to decode the results from queryparam\n",
prog_name);
exit(1);
}
#ifdef __minix_vmd
/* Get the uptime in clock ticks. */
if (sysutime(UTIME_UPTIME, &uptime) == -1)
{
fprintf(stderr, "%s: sysutime failed: %s\n", prog_name,
strerror(errno));
exit(1);
}
now= uptime.tv_sec * HZ + (uptime.tv_usec*HZ/1000000);
#else /* Minix 3 */
now= times(NULL);
#endif
for (i= 0; i<TCP_CONN_NR; i++)
print_conn(i, now);
exit(0);
}
bool p_isolation_metrics(QStringList timeseries_list, QString firings_path, QString metrics_out_path, QString pair_metrics_out_path, P_isolation_metrics_opts opts)
{
qDebug().noquote() << "Starting p_isolation_metrics";
DiskReadMda32 X(2, timeseries_list);
Mda firings(firings_path);
int M = X.N1();
int T = opts.clip_size;
QMap<int, P_isolation_metrics::ClusterData> cluster_data;
QVector<double> times(firings.N2());
QVector<int> labels(firings.N2());
for (bigint i = 0; i < firings.N2(); i++) {
times[i] = firings.value(1, i);
labels[i] = firings.value(2, i);
}
QSet<int> used_cluster_numbers_set;
for (bigint i = 0; i < labels.count(); i++) {
used_cluster_numbers_set.insert(labels[i]);
}
if (!opts.cluster_numbers.isEmpty()) {
used_cluster_numbers_set = used_cluster_numbers_set.intersect(opts.cluster_numbers.toSet());
}
QList<int> cluster_numbers = used_cluster_numbers_set.toList();
qSort(cluster_numbers);
qDebug().noquote() << "Computing cluster metrics...";
#pragma omp parallel for
for (int jj = 0; jj < cluster_numbers.count(); jj++) {
DiskReadMda32 X0;
QVector<double> times_k;
int k;
P_isolation_metrics_opts opts0;
#pragma omp critical
{
X0 = X;
k = cluster_numbers[jj];
for (bigint i = 0; i < labels.count(); i++) {
if (labels[i] == k)
times_k << times[i];
}
opts0 = opts;
}
QJsonObject tmp = P_isolation_metrics::get_cluster_metrics(X0, times_k, opts0);
#pragma omp critical
{
P_isolation_metrics::ClusterData CD;
CD.times = times_k;
CD.cluster_metrics = tmp;
cluster_data[k] = CD;
}
}
//compute templates
qDebug().noquote() << "Computing templates...";
Mda32 templates0;
{
QSet<int> cluster_numbers_set = cluster_numbers.toSet();
QVector<double> times;
QVector<int> labels;
for (bigint i = 0; i < firings.N2(); i++) {
bigint label0 = (bigint)firings.value(2, i);
if (cluster_numbers_set.contains(label0)) {
//inds << i;
times << firings.value(1, i);
labels << label0;
}
}
//templates0 = compute_templates_0(X, times, labels, opts.clip_size);
templates0 = compute_templates_in_parallel(X, times, labels, opts.clip_size);
}
qDebug().noquote() << "Determining pairs to compare...";
QJsonArray cluster_pairs;
int num_comparisons_per_cluster = 10;
QSet<QString> pairs_to_compare = P_isolation_metrics::get_pairs_to_compare(templates0, num_comparisons_per_cluster, cluster_numbers, opts);
QList<QString> pairs_to_compare_list = pairs_to_compare.toList();
qSort(pairs_to_compare_list);
#pragma omp parallel for
for (int jj = 0; jj < pairs_to_compare_list.count(); jj++) {
QString pairstr;
int k1, k2;
QVector<double> times_k1, times_k2;
P_isolation_metrics_opts opts0;
DiskReadMda32 X0;
#pragma omp critical
{
pairstr = pairs_to_compare_list[jj];
QStringList vals = pairstr.split("-");
k1 = vals[0].toInt();
k2 = vals[1].toInt();
times_k1 = cluster_data.value(k1).times;
times_k2 = cluster_data.value(k2).times;
opts0 = opts;
X0 = X;
}
QJsonObject pair_metrics = P_isolation_metrics::get_pair_metrics(X0, times_k1, times_k2, opts0);
#pragma omp critical
{
QJsonObject tmp;
tmp["label"] = QString("%1,%2").arg(k1).arg(k2);
tmp["metrics"] = pair_metrics;
double overlap = pair_metrics["overlap"].toDouble();
if (1 - overlap < cluster_data[k1].isolation) {
cluster_data[k1].isolation = 1 - overlap;
cluster_data[k1].overlap_cluster = k2;
}
if (1 - overlap < cluster_data[k2].isolation) {
cluster_data[k2].isolation = 1 - overlap;
cluster_data[k2].overlap_cluster = k1;
}
cluster_pairs.push_back(tmp);
}
}
if (opts.compute_bursting_parents) {
qDebug().noquote() << "Computing bursting parents...";
for (int jj = 0; jj < cluster_numbers.count(); jj++) {
int k1 = cluster_numbers[jj];
Mda32 template1;
templates0.getChunk(template1, 0, 0, k1 - 1, M, T, 1);
cluster_data[k1].bursting_parent = 0;
for (int kk = 0; kk < cluster_numbers.count(); kk++) {
int k2 = cluster_numbers[kk];
Mda32 template2;
templates0.getChunk(template2, 0, 0, k2 - 1, M, T, 1);
if (P_isolation_metrics::is_bursting_parent_candidate(template1, template2, opts)) {
bool verbose = false;
if (P_isolation_metrics::test_bursting_timing(cluster_data[k1].times, cluster_data[k2].times, opts, verbose)) {
cluster_data[k1].bursting_parent = k2;
}
}
}
}
}
qDebug().noquote() << "preparing clusters array";
QJsonArray clusters;
foreach (int k, cluster_numbers) {
QJsonObject tmp;
tmp["label"] = k;
cluster_data[k].cluster_metrics["isolation"] = cluster_data[k].isolation;
cluster_data[k].cluster_metrics["overlap_cluster"] = cluster_data[k].overlap_cluster;
if (opts.compute_bursting_parents)
cluster_data[k].cluster_metrics["bursting_parent"] = cluster_data[k].bursting_parent;
tmp["metrics"] = cluster_data[k].cluster_metrics;
clusters.push_back(tmp);
}
static void perf_get_info(FB_API_HANDLE* handle, P* perf)
{
/**************************************
*
* P E R F _ g e t _ i n f o
*
**************************************
*
* Functional description
* Acquire timing and performance information. Some info comes
* from the system and some from the database.
*
**************************************/
SSHORT buffer_length, item_length;
ISC_STATUS_ARRAY jrd_status;
#ifdef HAVE_GETTIMEOFDAY
struct timeval tp;
#else
struct timeb time_buffer;
#define LARGE_NUMBER 696600000 // to avoid overflow, get rid of decades)
#endif
// If there isn't a database, zero everything out
if (!*handle) {
memset(perf, 0, sizeof(PERF));
}
// Get system time
times(&perf->perf_times);
#ifdef HAVE_GETTIMEOFDAY
GETTIMEOFDAY(&tp);
perf->perf_elapsed = tp.tv_sec * 100 + tp.tv_usec / 10000;
#else
ftime(&time_buffer);
perf->perf_elapsed = (time_buffer.time - LARGE_NUMBER) * 100 + (time_buffer.millitm / 10);
#endif
if (!*handle)
return;
SCHAR buffer[256];
buffer_length = sizeof(buffer);
item_length = sizeof(items);
isc_database_info(jrd_status, handle, item_length, items, buffer_length, buffer);
const char* p = buffer;
while (true)
switch (*p++)
{
case isc_info_reads:
perf->perf_reads = get_parameter(&p);
break;
case isc_info_writes:
perf->perf_writes = get_parameter(&p);
break;
case isc_info_marks:
perf->perf_marks = get_parameter(&p);
break;
case isc_info_fetches:
perf->perf_fetches = get_parameter(&p);
break;
case isc_info_num_buffers:
perf->perf_buffers = get_parameter(&p);
break;
case isc_info_page_size:
perf->perf_page_size = get_parameter(&p);
break;
case isc_info_current_memory:
perf->perf_current_memory = get_parameter(&p);
break;
case isc_info_max_memory:
perf->perf_max_memory = get_parameter(&p);
break;
case isc_info_end:
return;
case isc_info_error:
switch (p[2])
{
case isc_info_marks:
perf->perf_marks = 0;
break;
case isc_info_current_memory:
perf->perf_current_memory = 0;
break;
case isc_info_max_memory:
perf->perf_max_memory = 0;
break;
}
{
const SLONG temp = isc_vax_integer(p, 2);
fb_assert(temp <= MAX_SSHORT);
p += temp + 2;
}
perf->perf_marks = 0;
break;
default:
return;
}
}
int main(int argc, char *argv[])
{
int ii;
double ttim, utim, stim, tott;
struct tms runtimes;
subharminfo **subharminfs;
accelobs obs;
infodata idata;
GSList *cands = NULL;
Cmdline *cmd;
/* Prep the timer */
tott = times(&runtimes) / (double) CLK_TCK;
/* Call usage() if we have no command line arguments */
if (argc == 1) {
Program = argv[0];
printf("\n");
usage();
exit(1);
}
/* Parse the command line using the excellent program Clig */
cmd = parseCmdline(argc, argv);
#ifdef DEBUG
showOptionValues();
#endif
printf("\n\n");
printf(" Fourier-Domain Acceleration Search Routine\n");
printf(" by Scott M. Ransom\n\n");
/* Create the accelobs structure */
create_accelobs(&obs, &idata, cmd, 1);
/* Zap birdies if requested and if in memory */
if (cmd->zaplistP && !obs.mmap_file && obs.fft) {
int numbirds;
double *bird_lobins, *bird_hibins, hibin;
/* Read the Standard bird list */
numbirds = get_birdies(cmd->zaplist, obs.T, cmd->baryv,
&bird_lobins, &bird_hibins);
/* Zap the birdies */
printf("Zapping them using a barycentric velocity of %.5gc.\n\n", cmd->baryv);
hibin = obs.N / 2;
for (ii = 0; ii < numbirds; ii++) {
if (bird_lobins[ii] >= hibin)
break;
if (bird_hibins[ii] >= hibin)
bird_hibins[ii] = hibin - 1;
zapbirds(bird_lobins[ii], bird_hibins[ii], NULL, obs.fft);
}
free(bird_lobins);
free(bird_hibins);
}
printf("Searching with up to %d harmonics summed:\n",
1 << (obs.numharmstages - 1));
printf(" f = %.1f to %.1f Hz\n", obs.rlo / obs.T, obs.rhi / obs.T);
printf(" r = %.1f to %.1f Fourier bins\n", obs.rlo, obs.rhi);
printf(" z = %.1f to %.1f Fourier bins drifted\n\n", obs.zlo, obs.zhi);
/* Generate the correlation kernels */
printf("Generating correlation kernels:\n");
subharminfs = create_subharminfos(obs.numharmstages, (int) obs.zhi);
printf("Done generating kernels.\n\n");
printf("Starting the search.\n");
/* Don't use the *.txtcand files on short in-memory searches */
if (!obs.dat_input) {
printf(" Working candidates in a test format are in '%s'.\n\n",
obs.workfilenm);
}
/* Start the main search loop */
{
double startr = obs.rlo, lastr = 0, nextr = 0;
ffdotpows *fundamental;
while (startr + ACCEL_USELEN * ACCEL_DR < obs.highestbin) {
/* Search the fundamental */
print_percent_complete(startr - obs.rlo,
obs.highestbin - obs.rlo, "search", 0);
nextr = startr + ACCEL_USELEN * ACCEL_DR;
lastr = nextr - ACCEL_DR;
fundamental = subharm_ffdot_plane(1, 1, startr, lastr,
&subharminfs[0][0], &obs);
cands = search_ffdotpows(fundamental, 1, &obs, cands);
if (obs.numharmstages > 1) { /* Search the subharmonics */
int stage, harmtosum, harm;
ffdotpows *subharmonic;
for (stage = 1; stage < obs.numharmstages; stage++) {
harmtosum = 1 << stage;
for (harm = 1; harm < harmtosum; harm += 2) {
subharmonic = subharm_ffdot_plane(harmtosum, harm, startr, lastr,
&subharminfs[stage][harm - 1],
&obs);
add_ffdotpows(fundamental, subharmonic, harmtosum, harm);
free_ffdotpows(subharmonic);
}
cands = search_ffdotpows(fundamental, harmtosum, &obs, cands);
}
}
free_ffdotpows(fundamental);
startr = nextr;
}
print_percent_complete(obs.highestbin - obs.rlo,
obs.highestbin - obs.rlo, "search", 0);
}
printf("\n\nDone searching. Now optimizing each candidate.\n\n");
free_subharminfos(obs.numharmstages, subharminfs);
{ /* Candidate list trimming and optimization */
int numcands;
GSList *listptr;
accelcand *cand;
fourierprops *props;
numcands = g_slist_length(cands);
if (numcands) {
/* Sort the candidates according to the optimized sigmas */
cands = sort_accelcands(cands);
/* Eliminate (most of) the harmonically related candidates */
if ((cmd->numharm > 1) && !(cmd->noharmremoveP))
eliminate_harmonics(cands, &numcands);
/* Now optimize each candidate and its harmonics */
print_percent_complete(0, 0, NULL, 1);
listptr = cands;
for (ii = 0; ii < numcands; ii++) {
print_percent_complete(ii, numcands, "optimization", 0);
cand = (accelcand *) (listptr->data);
optimize_accelcand(cand, &obs);
listptr = listptr->next;
}
print_percent_complete(ii, numcands, "optimization", 0);
/* Calculate the properties of the fundamentals */
props = (fourierprops *) malloc(sizeof(fourierprops) * numcands);
listptr = cands;
for (ii = 0; ii < numcands; ii++) {
cand = (accelcand *) (listptr->data);
/* In case the fundamental harmonic is not significant, */
/* send the originally determined r and z from the */
/* harmonic sum in the search. Note that the derivs are */
/* not used for the computations with the fundamental. */
calc_props(cand->derivs[0], cand->r, cand->z, 0.0, props + ii);
/* Override the error estimates based on power */
props[ii].rerr = (float) (ACCEL_DR) / cand->numharm;
props[ii].zerr = (float) (ACCEL_DZ) / cand->numharm;
listptr = listptr->next;
}
/* Write the fundamentals to the output text file */
output_fundamentals(props, cands, &obs, &idata);
/* Write the harmonics to the output text file */
output_harmonics(cands, &obs, &idata);
/* Write the fundamental fourierprops to the cand file */
obs.workfile = chkfopen(obs.candnm, "wb");
chkfwrite(props, sizeof(fourierprops), numcands, obs.workfile);
fclose(obs.workfile);
free(props);
printf("\n\n");
} else {
printf("No candidates above sigma = %.2f were found.\n\n", obs.sigma);
}
}
/* Finish up */
printf("Searched the following approx numbers of independent points:\n");
printf(" %d harmonic: %9lld\n", 1, obs.numindep[0]);
for (ii = 1; ii < obs.numharmstages; ii++)
printf(" %d harmonics: %9lld\n", 1 << ii, obs.numindep[ii]);
printf("\nTiming summary:\n");
tott = times(&runtimes) / (double) CLK_TCK - tott;
utim = runtimes.tms_utime / (double) CLK_TCK;
stim = runtimes.tms_stime / (double) CLK_TCK;
ttim = utim + stim;
printf(" CPU time: %.3f sec (User: %.3f sec, System: %.3f sec)\n",
ttim, utim, stim);
printf(" Total time: %.3f sec\n\n", tott);
printf("Final candidates in binary format are in '%s'.\n", obs.candnm);
printf("Final Candidates in a text format are in '%s'.\n\n", obs.accelnm);
free_accelobs(&obs);
g_slist_foreach(cands, free_accelcand, NULL);
g_slist_free(cands);
return (0);
}
static int Ptimes(lua_State *L) /** times() */
{
struct mytimes t;
t.elapsed = times(&t.t);
return doselection(L, 1, Stimes, Ftimes, &t);
}
clock_t get_now_time(void)
{
return times(&t);
}
