void *thread_cli_fun(void *arg) {
double busy;
int inx;
Msg *msg;
struct rusage r_start;
struct rusage r_stop;
struct timeval t_elapsed_data;
struct timeval t_elapsed_total;
struct timeval t_start_data;
struct timeval t_start_total;
struct timeval t_stop;
arg = arg; // touch
util_time_timer_start(&t_start_total);
util_time_timer_start(&t_start_data);
util_cpu_timer_start(&r_start);
for (inx = 0; inx < loop; inx++) {
if (verbose)
printf("count=%d\n", inx);
msg = msg_queue_remove(&mutex_pool, &queue_pool);
assert(msg != NULL);
if (csize) {
msg->cbuf = (char *) malloc(csize);
memcpy(msg->cbuf, send_buffer2, csize);
}
if (dsize) {
msg->dbuf = (char *) malloc(dsize);
memcpy(msg->dbuf, send_buffer, dsize);
}
msg_queue_add(&mutex_srv, &queue_srv, msg);
cv_signal(&cv_srv);
cv_wait(&cv_cli);
msg = msg_queue_remove(&mutex_cli, &queue_cli);
assert(msg != NULL);
msg_queue_add(&mutex_pool, &queue_pool, msg);
}
util_cpu_timer_stop(&r_stop);
util_time_timer_stop(&t_stop);
util_time_elapsed(&t_start_total, &t_stop, &t_elapsed_total);
util_time_elapsed(&t_start_data, &t_stop, &t_elapsed_data);
util_cpu_timer_busy(&r_start, &r_stop, &t_elapsed_data, &busy);
if (!bm) {
print_elapsed("", &t_elapsed_total);
print_elapsed(" (data)", &t_elapsed_data);
}
print_rate(bm, "", bidir ? 2 * loop : loop, dsize, &t_elapsed_data, busy);
return NULL;
}
static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
{
GList *list, *option_value = NULL;
char *address;
print_elapsed();
printf("Lease available\n");
address = g_dhcp_client_get_address(dhcp_client);
printf("address %s\n", address);
if (address == NULL)
return;
option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET);
for (list = option_value; list; list = list->next)
printf("sub-mask %s\n", (char *) list->data);
option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_DNS_SERVER);
for (list = option_value; list; list = list->next)
printf("domain-name-servers %s\n", (char *) list->data);
option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_DOMAIN_NAME);
for (list = option_value; list; list = list->next)
printf("domain-name %s\n", (char *) list->data);
option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_ROUTER);
for (list = option_value; list; list = list->next)
printf("routers %s\n", (char *) list->data);
option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_HOST_NAME);
for (list = option_value; list; list = list->next)
printf("hostname %s\n", (char *) list->data);
}
static void no_lease_cb(GDHCPClient *dhcp_client, gpointer user_data)
{
print_elapsed();
printf("No lease available\n");
g_main_loop_quit(main_loop);
}
spocp_result_t
get_rules( srv_t *srv )
{
spocp_result_t rc = SPOCP_SUCCESS;
int nrules = 0, r;
dbcmd_t dbc;
struct timeval start, end;
memset( &dbc, 0, sizeof( dbcmd_t ));
dbc.dback = srv->dback;
if (srv->dback) {
/*
* does the persistent database store need any initialization
* ?? * if( srv.dback->init ) srv.dback->init( dbcmd_t *dbc )
* ;
*/
if ((nrules = dback_read_rules(&dbc, srv, &rc)) < 0)
return rc;
}
if (nrules == 0) {
if (srv->rulefile) {
LOG(SPOCP_INFO)
traceLog(LOG_INFO, "Opening rules file \"%s\"",
srv->rulefile);
if (0)
gettimeofday(&start, NULL);
/*
dbc.dback = srv->dback;
dbc.handle = 0;
*/
r = read_rules(srv, srv->rulefile, &dbc) ;
if( r == -1 ) {
LOG(SPOCP_ERR)
traceLog(LOG_ERR,"Error while reading rules");
rc = SPOCP_OPERATIONSERROR;
}
if (0) {
gettimeofday(&end, NULL);
print_elapsed("readrule time:", start, end);
}
}
else
LOG(SPOCP_INFO)
traceLog(LOG_INFO, "No rule file to start with");
} else {
LOG(SPOCP_INFO)
traceLog(LOG_INFO,
"Got the rules from the persistent store, will not read the rulefile");
}
return rc;
}
int main() {
int good_queens[] = {4, 1, 3, 5, 7, 2, 0, 6};
int bad_queens[] = {4, 3, 1, 5, 7, 2, 0, 6};
board good_board = new_board_from_queens(8, good_queens);
board bad_board = new_board_from_queens(8, bad_queens);
boards solutions, diagonals;
int n;
printf("==== print_board(good_board) ====\n");
print_board(good_board);
printf("==== print_board_as_perm(good_board) ====\n");
print_board_as_perm(good_board);
printf("==== valid_diagonals ====\n");
printf(" good board : %i \n", valid_diagonals(8, good_queens));
printf(" bad board : %i \n", valid_diagonals(8, bad_queens));
free_board(good_board);
free_board(bad_board);
printf("==== small n behavior ====\n");
for (n=0; n<4; n++){
printf(" n=%i : ", n);
solutions = queens_search(n);
print_boards_as_perms(solutions);
free_boards(solutions);
}
printf("==== queens_search n=4 ====\n");
solutions = queens_search(4);
print_boards(solutions);
free_boards(solutions);
printf("==== search n=8 ====\n");
solutions = queens_search(8);
printf(" number of solutions = %i \n", solutions->count);
free_boards(solutions);
diagonals = queens_search_diagonals(8);
printf(" number of queens_search_diagonals = %i \n", diagonals->count);
free_boards(diagonals);
diagonals = in_both_diagonals(solutions); // same, another way
printf(" number of in_both_diagonals = %i \n", diagonals->count);
free_boards(diagonals);
printf("==== queens_search_diagonals for various n ====\n", n);
for (n=4; n<15; n++){
reset_timer();
diagonals = queens_search_diagonals(n);
printf(" n = %2i ; count = %7i ; time = ", n, diagonals->count);
print_elapsed(); printf("\n"); fflush(stdout);
free_boards(diagonals);
}
printf("=== memory check ===\n");
printf(" malloc() + calloc() - free() = %i \n\n", get_allocation_count());
return 0;
}
void time_iterator(const dtable * table, size_t count, ATX_DEF)
{
struct timeval start;
dtable::iter * iter = table->iterator(atx);
printf("Iterate %zu time%s... ", count, (count == 1) ? "" : "s");
fflush(stdout);
gettimeofday(&start, NULL);
for(size_t i = 0; i < count; i++)
{
iter->first();
while(iter->valid())
{
dtype key = iter->key();
dtype value = iter->value();
iter->next();
}
}
print_elapsed(&start);
delete iter;
}
int main(int argc, char *argv[]) {
int arg;
bool bm = false;
char *buf;
double busy;
bool chook = false;
bool client = false;
char errnobuf[100];
char error_txt[200];
int event_len;
char event_data[MS_MON_MAX_SYNC_DATA];
int ferr;
int inx;
int key;
int lerr;
int loop = 10;
int msid;
int pid;
char prog[MS_MON_MAX_PROCESS_PATH];
struct rusage r_start;
struct rusage r_stop;
const char *server_name = "$SRV";
int server_nid;
TPT_DECL (server_phandle);
int server_pid;
bool shook = false;
struct timeval t_elapsed;
struct timeval t_start;
struct timeval t_stop;
TAD zargs[] = {
{ "-bm", TA_Bool, TA_NOMAX, &bm },
{ "-chook", TA_Bool, TA_NOMAX, &chook },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-shook", TA_Bool, TA_NOMAX, &shook },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = msg_init(&argc, &argv);
arg_proc_args(zargs, false, argc, argv);
if (chook && client)
test_debug_hook("c", "c");
if (shook && !client)
test_debug_hook("s", "s");
util_test_start(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
proc_enable_external_wakeups(); // allow external wakeups
if (client) {
ferr = msg_mon_get_process_info(NULL, &server_nid, &server_pid);
TEST_CHK_FEOK(ferr);
sprintf(prog, "%s/%s", getenv("PWD"), argv[0]);
for (arg = 0; arg < argc; arg++)
if (strcmp(argv[arg], "-client") == 0) // start_process
argv[arg] = (char *) "-server";
ferr = msg_mon_start_process(prog, // prog
(char *) server_name, // name
NULL, // ret name
argc,
argv,
TPT_REF(server_phandle),
0, // open
NULL, // oid
MS_ProcessType_Generic, // type
0, // priority
0, // debug
0, // backup
&server_nid, // nid
&server_pid, // pid
NULL, // infile
NULL); // outfile
printf("process started, err=%d\n", ferr);
TEST_CHK_FEOK(ferr);
}
util_gethostname(my_name, sizeof(my_name));
lerr = XWAIT(LREQ, -1); // remove first LREQ
assert(lerr == LREQ);
ferr = msg_mon_get_my_segid(&key);
TEST_CHK_FEOK(ferr);
// process-wait for client/server/shell
ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, 3, NULL, false);
TEST_CHK_FEOK(ferr);
if (client) {
ferr = msg_mon_event_wait(1, &event_len, event_data);
TEST_CHK_FEOK(ferr);
msid = shmget(key, sizeof(recv_buffer), 0640);
if (msid == -1) {
perror("client shmget");
sprintf(error_txt, "client shmget(%d)=%s\n",
key,
strerror_r(errno, errnobuf, sizeof(errnobuf)));
}
assert(msid != -1);
buf = (char *) shmat(msid, NULL, 0);
assert(buf != NULL);
} else {
msid = shmget(key, sizeof(recv_buffer), IPC_CREAT | 0640);
if (msid == -1) {
perror("server shmget");
sprintf(error_txt, "server shmget(%d)=%s\n",
key,
strerror_r(errno, errnobuf, sizeof(errnobuf)));
}
assert(msid != -1);
buf = (char *) shmat(msid, NULL, 0);
assert(buf != NULL);
ferr =
msg_mon_event_send(-1, // nid
-1, // pid
MS_ProcessType_Undefined, // process-type
1, // event-id
0, // event-len
NULL); // event-data
TEST_CHK_FEOK(ferr);
ferr = msg_mon_event_wait(1, &event_len, event_data);
TEST_CHK_FEOK(ferr);
}
util_time_timer_start(&t_start);
util_cpu_timer_start(&r_start);
if (client) {
pid = server_pid;
for (inx = 0; inx < loop; inx++) {
lerr = XPROCESS_AWAKE_(pid, LREQ);
assert(lerr == XZFIL_ERR_OK);
lerr = XWAIT(LDONE, -1);
assert(lerr == LDONE);
}
} else {
ferr = msg_mon_get_process_info((char *) "$CLI", &server_nid, &pid);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
lerr = XWAIT(LREQ, -1);
assert(lerr == LREQ);
lerr = XPROCESS_AWAKE_(pid, LDONE);
assert(lerr == XZFIL_ERR_OK);
}
}
util_cpu_timer_stop(&r_stop);
util_time_timer_stop(&t_stop);
util_time_elapsed(&t_start, &t_stop, &t_elapsed);
util_cpu_timer_busy(&r_start, &r_stop, &t_elapsed, &busy);
if (client) {
if (!bm)
print_elapsed("", &t_elapsed);
print_rate(bm, "", loop, 1024, &t_elapsed, busy);
} else
print_server_busy(bm, "", busy);
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
int arg;
char *argvn[100];
char argvna[100][200];
bool chook = false;
bool client = false;
int ferr;
int linx;
int loop = 1;
char name[20];
int pid;
bool server0 = false;
bool server1 = false;
bool server2 = false;
char *server_name = (char *) "$SRV";
bool shook = false;
int status;
bool strace = false;
struct timeval t_elapsed;
struct timeval t_start;
struct timeval t_stop;
bool test[] = { true, true, true };
bool test0 = false;
bool test1 = false;
bool test2 = false;
int tinx;
int uerr;
bool verbose = false;
const char *who;
TAD zargs[] = {
{ "-chook", TA_Bool, TA_NOMAX, &chook },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-server0", TA_Bool, TA_NOMAX, &server0 },
{ "-server1", TA_Bool, TA_NOMAX, &server1 },
{ "-server2", TA_Bool, TA_NOMAX, &server2 },
{ "-shook", TA_Bool, TA_NOMAX, &shook },
{ "-strace", TA_Bool, TA_NOMAX, &strace },
{ "-test0", TA_Bool, TA_NOMAX, &test0 },
{ "-test1", TA_Bool, TA_NOMAX, &test1 },
{ "-test2", TA_Bool, TA_NOMAX, &test2 },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
arg_proc_args(zargs, false, argc, argv);
if (test0) {
test[0] = true;
test[1] = false;
test[2] = false;
} else if (test1) {
test[0] = false;
test[1] = true;
test[2] = false;
} else if (test2) {
test[0] = false;
test[1] = false;
test[2] = true;
}
if (client)
who = "cli";
else if (server0)
who = "srv0";
else if (server1)
who = "srv1";
else
who = "srv2";
if (verbose)
for (arg = 0; arg < argc; arg++)
printf("%s: argv[%d]=%s\n", who, arg, argv[arg]);
if (chook && client)
test_debug_hook("c", "c");
if (shook && !client)
test_debug_hook("s", "s");
if (client) {
if (verbose)
printf("%s: about to msg_init\n", who);
ferr = msg_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
} else if (server0) {
if (verbose)
printf("%s: about to msg_init_attach\n", who);
ferr = msg_init_attach(&argc, &argv, false, server_name);
TEST_CHK_FEOK(ferr);
} else if (server1) {
if (verbose)
printf("%s: about to msg_init_attach\n", who);
ferr = msg_test_enable_client_only();
TEST_CHK_FEOK(ferr);
ferr = msg_init_attach(&argc, &argv, false, server_name);
TEST_CHK_FEOK(ferr);
}
if (client)
util_test_start(client);
if (verbose)
printf("%s: about to msg_mon_process_startup\n", who);
if (client || server0 || server1) {
ferr = msg_mon_process_startup(!client); // system messages
TEST_CHK_FEOK(ferr);
}
if (client) {
for (linx = 0; linx < loop; linx++) {
for (tinx = 0; tinx < 3; tinx++) {
if (!test[tinx])
continue;
for (arg = 0; arg < argc; arg++) {
if (strcmp(argv[arg], "-client") == 0) { // start_process
sprintf(argvna[arg], "-server%d", tinx);
argvn[arg] = argvna[arg];
} else
argvn[arg] = argv[arg];
}
argvn[arg] = NULL;
if (strace) {
sprintf(argvna[0], "xt172ms%d", tinx);
argvn[0] = argvna[0];
}
if (verbose)
printf("%s: about to fork-exec\n", who);
util_time_timer_start(&t_start);
pid = fork();
switch (pid) {
case 0:
// child
uerr = execvp(argvn[0], argvn);
if (uerr == -1)
perror("execvp");
exit(0);
case -1:
// parent
perror("fork");
exit(1);
default:
// parent
while (wait(&status) != pid)
;
util_time_timer_stop(&t_stop);
util_time_elapsed(&t_start, &t_stop, &t_elapsed);
sprintf(name, " server%d", tinx);
print_elapsed(name, &t_elapsed);
}
TEST_CHK_FEOK(ferr);
}
}
}
if (client || server0 || server1) {
if (verbose)
printf("%s: about to msg_mon_process_shutdown\n", who);
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
}
if (client) {
util_test_finish(client);
util_time_timer_stop(&t_stop);
util_time_elapsed(&t_start, &t_stop, &t_elapsed);
print_elapsed(" client", &t_elapsed);
}
if (verbose)
printf("%s: about to exit main\n", who);
return 0;
}
int main(int argc, char *argv[]) {
bool bidir = false;
bool bm = false;
void *buf;
double busy;
_xcc_status cc;
int count_read;
int count_written;
int count_xferred;
int dsize = 1024;
int ferr;
short filenum[MAX_SERVERS];
short filenumr;
int inx;
int loop = 10;
int max;
int maxsp = 1;
bool mq = false;
bool nocopy = false;
bool nowaitc = false;
bool nowaits = false;
int pinx;
struct rusage r_start;
struct rusage r_stop;
char *recv_buffer_ptr;
RI_Type ri;
short sender_len;
int sys_msg;
struct timeval t_elapsed_data;
struct timeval t_elapsed_open;
struct timeval t_elapsed_total;
struct timeval t_start_data;
struct timeval t_start_total;
struct timeval t_stop;
SB_Tag_Type tag;
short tfilenum;
int timeout = -1;
bool verbose = false;
TAD zargs[] = {
{ "-bidir", TA_Bool, TA_NOMAX, &bidir },
{ "-bm", TA_Bool, TA_NOMAX, &bm },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-dsize", TA_Int, MAX_DBUF, &dsize },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxcp", TA_Int, MAX_CLIENTS, &maxcp },
{ "-maxsp", TA_Int, MAX_SERVERS, &maxsp },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-nocopy", TA_Bool, TA_NOMAX, &nocopy },
{ "-nowaitc", TA_Bool, TA_NOMAX, &nowaitc },
{ "-nowaits", TA_Bool, TA_NOMAX, &nowaits },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "", TA_End, TA_NOMAX, NULL }
};
for (inx = 0; inx < MAX_CLIENTS; inx++)
account[inx] = 0;
signal(SIGUSR2, printaccount);
ferr = file_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, file_debug_hook);
arg_proc_args(zargs, false, argc, argv);
if (maxcp < 0)
maxcp = 1;
if (maxsp < 0)
maxsp = 1;
util_test_start(client);
ferr = file_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
if (nocopy) {
ferr = file_buf_register(buf_alloc, buf_free);
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
TEST_CHK_FEOK(ferr);
// process-wait for clients/servers/shell
ferr = msfs_util_wait_process_count(MS_ProcessType_Generic,
maxcp + maxsp + 1,
NULL,
verbose);
if (client)
sleep(1);
util_time_timer_start(&t_start_total);
if (client) {
inx = atoi(&my_name[4]);
printf("dsize=%d, loop=%d\n", dsize, loop);
for (pinx = 0; pinx < maxsp; pinx++) {
sprintf(serv, "$srv%d", pinx);
ferr = BFILE_OPEN_(serv, (short) strlen(serv), &filenum[pinx],
0, 0, nowaitc ? (short) 1 : (short) 0,
0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
}
util_time_timer_start(&t_start_data);
util_cpu_timer_start(&r_start);
util_time_elapsed(&t_start_total, &t_start_data, &t_elapsed_open);
max = loop;
for (inx = 0; inx < max; inx++) {
for (pinx = 0; pinx < maxsp; pinx++) {
if (pinx == 0) {
if (verbose)
printf("%s-count=%d\n", my_name, inx);
else if (mq && ((inx % 1000) == 0))
printf("%s-count=%d\n", my_name, inx);
}
cc = BWRITEREADX(filenum[pinx],
send_buffer,
(int) dsize, // cast
bidir ? dsize : 0,
&count_read,
0);
}
for (pinx = 0; pinx < maxsp; pinx++) {
if (nowaitc) {
TEST_CHK_CCEQ(cc);
tfilenum = filenum[pinx];
cc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_CCEQ(cc);
}
}
}
} else {
ferr = BFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr,
0, 0, nowaits ? (short) 1 : (short) 0, // nowait
1, 0, // sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
util_time_timer_start(&t_start_data);
util_cpu_timer_start(&r_start);
max = maxcp * loop;
for (inx = 0; inx < max; inx++) {
if (nocopy) {
cc = file_buf_readupdatex(filenumr,
&recv_buffer_ptr,
&count_read,
0);
buf_free(recv_buffer_ptr);
} else
cc = BREADUPDATEX(filenumr,
recv_buffer,
(int) dsize, // cast
&count_read,
0);
if (nowaits) {
tfilenum = -1;
cc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
// don't check cc - could be sys msg
sys_msg = _xstatus_ne(cc);
} else
sys_msg = _xstatus_ne(cc);
if (sys_msg)
inx--;
if (!sys_msg) {
getri(&ri);
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(ri.sender),
NULL, // cpu
NULL, // pin
NULL, // nodenumber
NULL, // nodename
0, // nodename
NULL, // nodename_length
sender,
sizeof(sender),
&sender_len,
NULL); // sequence_number
TEST_CHK_FEOK(ferr);
sender[sender_len] = 0;
if (verbose)
printf("sender=%s\n", sender);
char *p = &sender[4]; // past $cli
int sender_inx = atoi(p);
account[sender_inx]++;
}
cc = BREPLYX(recv_buffer,
bidir ? dsize : 0,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
}
}
util_cpu_timer_stop(&r_stop);
util_time_timer_stop(&t_stop);
util_time_elapsed(&t_start_total, &t_stop, &t_elapsed_total);
util_time_elapsed(&t_start_data, &t_stop, &t_elapsed_data);
util_cpu_timer_busy(&r_start, &r_stop, &t_elapsed_data, &busy);
if (client) {
if (!bm) {
print_elapsed("", &t_elapsed_total);
print_elapsed(" (data)", &t_elapsed_data);
print_elapsed(" (open)", &t_elapsed_open);
}
print_rate(bm, "", bidir ? 2 * loop : loop, dsize, &t_elapsed_data, busy);
} else
print_server_busy(bm, "", busy);
if (client) {
for (pinx = 0; pinx < maxsp; pinx++) {
ferr = BFILE_CLOSE_(filenum[pinx], 0);
TEST_CHK_FEOK(ferr);
}
} else {
ferr = BFILE_CLOSE_(filenumr, 0);
TEST_CHK_FEOK(ferr);
ferr = file_mon_process_close();
TEST_CHK_FEOK(ferr);
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
printaccount(0);
return 0;
}
int
main(int argc, char **argv)
{
int debug = 0, conftest = 0, nodaemon = 0;
int i = 0;
unsigned int clilen;
struct sockaddr_in cliaddr;
struct timeval start, end;
char *cnfg = DEF_CNFG;
char localhost[MAXNAMLEN + 1], path[MAXNAMLEN + 1];
FILE *pidfp;
octet_t oct;
ruleset_t *rs;
/*
* Who am I running as ?
*/
uname(&myname);
/*
* spocp_err = 0 ;
*/
memset(&srv, 0, sizeof(srv_t));
pthread_mutex_init(&(srv.mutex), NULL);
pthread_mutex_init(&(srv.mlock), NULL);
gethostname(localhost, MAXNAMLEN);
#ifdef HAVE_GETDOMAINNAME
getdomainname(path, MAXNAMLEN);
#else
{
char *pos;
if(pos = strstr(localhost, ".")) strncpy(path, pos+1, MAXNAMLEN);
else strcpy(path, "");
}
#endif
if (0)
printf("Domain: %s\n", path);
srv.hostname = Strdup(localhost);
/*
* truncating input strings to reasonable length
*/
for (i = 0; i < argc; i++)
if (strlen(argv[i]) > 512)
argv[i][512] = '\0';
while ((i = getopt(argc, argv, "Dhrtf:d:")) != EOF) {
switch (i) {
case 'D':
nodaemon = 1;
break;
case 'f':
cnfg = Strdup(optarg);
break;
case 'd':
debug = atoi(optarg);
if (debug < 0)
debug = 0;
break;
case 't':
conftest = 1;
break;
case 'r':
srv.readonly = 1;
case 'h':
default:
fprintf(stderr, "Usage: %s [-t] ", argv[0]);
fprintf(stderr, "[-f configfile] ");
fprintf(stderr, "[-D] [-d debuglevel]\n");
exit(0);
}
}
srv.root = ruleset_new(0);
if (srv_init(&srv, cnfg) < 0)
exit(1);
if (srv.port && srv.uds) {
fprintf(stderr,
"Sorry are not allowed to listen on both a unix domain socket and a port\n");
exit(1);
}
if (srv.logfile)
spocp_open_log(srv.logfile, debug);
else if (debug)
spocp_open_log(0, debug);
if (srv.name){
localcontext = (char *) Calloc(strlen(srv.name) + strlen("//") + 1,
sizeof(char));
/* Flawfinder: ignore */
sprintf(localcontext, "//%s", srv.name);
}
else {
localcontext = (char *) Calloc(strlen(localhost) + strlen("//") + 1,
sizeof(char));
/* Flawfinder: ignore */
sprintf(localcontext, "//%s", localhost);
}
/*
* where I put the access rules for access to this server and its
* rules
*/
snprintf(path, MAXNAMLEN, "%s/server", localcontext);
oct_assign(&oct, path);
if ((rs = ruleset_create(&oct, srv.root)) == 0)
exit(1);
rs->db = db_new();
/*
* access rules for operations
*/
snprintf(path, MAXNAMLEN, "%s/operation", localcontext);
oct_assign(&oct, path);
if ((rs = ruleset_create(&oct, srv.root)) == 0)
exit(1);
rs->db = db_new();
LOG(SPOCP_INFO) {
traceLog(LOG_INFO, "Local context: \"%s\"", localcontext);
traceLog(LOG_INFO, "initializing backends");
if (srv.root->db)
plugin_display(srv.plugin);
}
if (srv.plugin) {
run_plugin_init(&srv);
}
if ( get_rules( &srv ) != SPOCP_SUCCESS )
exit(1);
/*ruleset_tree( srv.root, 0);*/
/* If only testing configuration and rulefile this is as far as I go */
if (conftest) {
traceLog(LOG_INFO,"Configuration was OK");
exit(0);
}
gettimeofday(&start, NULL);
if (srv.port || srv.uds) {
/*
* stdin and stdout will not be used from here on, close to
* save file descriptors
*/
fclose(stdin);
fclose(stdout);
#ifdef HAVE_SSL
/*
* ----------------------------------------------------------
*/
/*
* build our SSL context, whether it will ever be used or not
*/
/*
* mutex'es for openSSL to use
*/
THREAD_setup();
if (srv.certificateFile && srv.privateKey && srv.caList) {
traceLog(LOG_INFO,"Initializing the TLS/SSL environment");
if (!(srv.ctx = tls_init(&srv))) {
return FALSE;
}
}
/*
* ----------------------------------------------------------
*/
#endif
#ifdef HAVE_SASL
{
int r = sasl_server_init(sasl_cb, "spocp");
if (r != SASL_OK) {
traceLog( LOG_ERR,
"Unable to initialized SASL library: %s",
sasl_errstring(r, NULL, NULL));
return FALSE;
}
}
#endif
saci_init();
if( nodaemon == 0 ) {
#ifdef HAVE_DAEMON
if (daemon(1, 1) < 0) {
fprintf(stderr, "couldn't go daemon\n");
exit(1);
}
#else
daemon_init("spocp", 0);
#endif
}
if (srv.pidfile) {
/*
* Write the PID file.
*/
pidfp = fopen(srv.pidfile, "w");
if (pidfp == (FILE *) 0) {
fprintf(stderr,
"Couldn't open pidfile \"%s\"\n",
srv.pidfile);
exit(1);
}
fprintf(pidfp, "%d\n", (int) getpid());
fclose(pidfp);
}
if (srv.port) {
LOG(SPOCP_INFO) traceLog( LOG_INFO,
"Asked to listen on port %d", srv.port);
if ((srv.listen_fd =
spocp_stream_socket(srv.port)) < 0)
exit(1);
srv.id = (char *) Malloc(16);
sprintf(srv.id, "spocp-%d", srv.port);
srv.type = AF_INET;
} else {
LOG(SPOCP_INFO)
traceLog(LOG_INFO,"Asked to listen on unix domain socket");
if ((srv.listen_fd =
spocp_unix_domain_socket(srv.uds)) < 0)
exit(1);
srv.id = (char *) Malloc(7 + strlen(srv.uds));
/* Flawfinder: ignore */
sprintf(srv.id, "spocp-%s", srv.uds);
srv.type = AF_UNIX;
}
xsignal(SIGCHLD, sig_chld);
xsignal(SIGPIPE, sig_pipe);
xsignal(SIGINT, sig_int);
xsignal(SIGTERM, sig_term);
xsignal(SIGUSR1, sig_usr1);
clilen = sizeof(cliaddr);
DEBUG(SPOCP_DSRV) traceLog(LOG_DEBUG,"Creating threads");
/*
* returns the pool the threads are picking work from
*/
srv.work = tpool_init(srv.threads, 64, 1);
spocp_srv_run(&srv);
} else {
conn_t *conn;
saci_init();
DEBUG(SPOCP_DSRV) traceLog(LOG_DEBUG,"---->");
LOG(SPOCP_INFO) traceLog(LOG_INFO,"Reading STDIN");
/*
* If I want to use this I have to do init_server() first
* conn = spocp_open_connection( STDIN_FILENO, &srv ) ;
*/
/*
* this is much simpler
*/
conn = conn_new();
conn_setup(conn, &srv, STDIN_FILENO, "localhost", "127.0.0.1");
LOG(SPOCP_INFO) traceLog(LOG_INFO,"Running server");
spocp_server((void *) conn);
gettimeofday(&end, NULL);
print_elapsed("query time:", start, end);
conn_free( conn );
}
srv_free( &srv );
if (cnfg != DEF_CNFG)
Free( cnfg );
exit(0);
}
int main(int argc, char *argv[]) {
_xcc_status cc;
bool client = false;
unsigned short count_read;
unsigned short count_written;
int ferr;
short filenumr;
short filenums[MAXSRV];
int inxl;
int inxs;
int loop = 10;
int maxsp = 2;
bool verbose = false;
xzsys_ddl_smsg_def *sys_msg = (xzsys_ddl_smsg_def *) recv_buffer;
struct timeval t_elapsed_close;
struct timeval t_elapsed_closem1;
struct timeval t_elapsed_open;
struct timeval t_elapsed_openm1;
struct timeval t_start_close;
struct timeval t_start_closem1;
struct timeval t_start_open;
struct timeval t_start_openm1;
struct timeval t_stop_close;
struct timeval t_stop_closem1;
struct timeval t_stop_open;
struct timeval t_stop_openm1;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxsp", TA_Int, MAXSRV, &maxsp },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = file_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, file_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = file_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
if (client) {
util_time_timer_start(&t_start_open);
for (inxs = 0; inxs < maxsp; inxs++) {
ferr = XFILE_OPEN_((char *) "$srv", 4, &filenums[inxs],
0, 0, 0, 0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
if (inxs == 0)
util_time_timer_start(&t_start_openm1);
}
util_time_timer_stop(&t_stop_open);
util_time_timer_stop(&t_stop_openm1);
for (inxs = 0; inxs < maxsp; inxs++) {
for (inxl = 0; inxl < loop; inxl++) {
sprintf(send_buffer, "hello, greetings %d from %s, inx=%d",
inxs, my_name, inxl);
cc = XWRITEREADX(filenums[inxs],
send_buffer,
(unsigned short) (strlen(send_buffer) + 1), // cast
BUFSIZ,
&count_read,
0);
TEST_CHK_CCEQ(cc);
printf("%s\n", send_buffer);
}
}
util_time_timer_start(&t_start_close);
util_time_timer_start(&t_start_closem1);
for (inxs = 0; inxs < maxsp; inxs++) {
if (inxs == (maxsp - 1))
util_time_timer_stop(&t_stop_closem1);
ferr = XFILE_CLOSE_(filenums[inxs], 0);
TEST_CHK_FEOK(ferr);
}
util_time_timer_stop(&t_stop_close);
util_time_elapsed(&t_start_open, &t_stop_open, &t_elapsed_open);
util_time_elapsed(&t_start_openm1, &t_stop_openm1, &t_elapsed_openm1);
util_time_elapsed(&t_start_close, &t_stop_close, &t_elapsed_close);
util_time_elapsed(&t_start_closem1, &t_stop_closem1, &t_elapsed_closem1);
print_elapsed(" (open)", &t_elapsed_open);
print_elapsed(" (open-1st)", &t_elapsed_openm1);
print_elapsed(" (close)", &t_elapsed_close);
print_elapsed(" (close-lst)", &t_elapsed_closem1);
} else {
ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr,
0, 0, 0,
1, 0, // sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
// process opens
for (inxs = 0; inxs < maxsp; inxs++) {
cc = XREADUPDATEX(filenumr,
recv_buffer,
BUFSIZ,
&count_read,
0);
TEST_CHK_CCNE(cc);
if (verbose) {
int mt = sys_msg->u_z_msg.z_msgnumber[0];
printf("inx=%d, type=%d\n", inxs, mt);
}
cc = XREPLYX(recv_buffer,
0,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
}
for (inxs = 0; inxs < maxsp; inxs++) {
for (inxl = 0; inxl < loop; inxl++) {
cc = XREADUPDATEX(filenumr,
recv_buffer,
BUFSIZ,
&count_read,
0);
TEST_CHK_CCEQ(cc);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
count_read = (unsigned short) (strlen(recv_buffer) + 1); // cast
cc = XREPLYX(recv_buffer,
count_read,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
}
}
// process closes
for (inxs = 0; inxs < maxsp; inxs++) {
cc = XREADUPDATEX(filenumr,
recv_buffer,
BUFSIZ,
&count_read,
0);
TEST_CHK_CCNE(cc);
if (verbose) {
int mt = sys_msg->u_z_msg.z_msgnumber[0];
printf("inx=%d, type=%d\n", inxs, mt);
}
cc = XREPLYX(recv_buffer,
0,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
}
ferr = XFILE_CLOSE_(filenumr, 0);
TEST_CHK_FEOK(ferr);
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
void print_elapsed(const struct timeval * start, bool elapsed)
{
struct timeval end;
gettimeofday(&end, NULL);
print_elapsed(start, &end, elapsed);
}
/*==============================================================
* Main Program
*==============================================================*/
int main(int argc, char *argv[]) {
int numints = 0;
int numiterations = 0;
FILE *fp;
int* data = NULL;
long* partial_sums = NULL;
long sum_int;
long total_sum = 0;
struct timeval start, end; /* gettimeofday stuff */
struct timezone tzp;
if( argc < 3) {
printf("Usage: %s [numints] [numiterations]\n\n", argv[0]);
exit(1);
}
numints = atoi(argv[1]);
numiterations = atoi(argv[2]);
//printf("\nExecuting %s: nthreads=%d, numints=%d, numiterations=%d\n",
//argv[0], omp_get_max_threads(), numints, numiterations);
/* Allocate shared memory, enough for each thread to have numints*/
data = (int *) malloc(sizeof(int) * numints);
/* Allocate shared memory for partial_sums */
partial_sums = (long *) malloc(sizeof(long) * numints );
//partial_sums_f = (long *) malloc(sizeof(long) * numints );
/*****************************************************
* Generate the random ints in parallel *
*****************************************************/
int i=0;
srand(i + time(NULL));
for(i = 0; i < numints; ++i) {
data[i] = rand()/10000;
}
int iterations;
gettimeofday(&start, &tzp); // time point from where the actual calculation begins
for (iterations=0;iterations<numiterations;iterations++) {
sum_int=0;
for(i=0; i< numints; i++){
sum_int = sum_int+data[i];
partial_sums[i] = sum_int;
}
}
gettimeofday(&end, &tzp); // time point from where the actual calculation begins
print_elapsed("Summation", &start, &end, numiterations);
free(data);
free(partial_sums);
return(0);
}
int main(int argc, char *argv[])
{
FILE *fd = NULL;
Tstate prev_state;
char filename[256];
time_t rstart, rend, tnow;
struct tm tm;
char tag[32] = "default";
char *home = getenv("HOME");
// check for explicit tag name
if (argc > 2 && argv[1][1] == 't') {
strncpy(tag, argv[2], sizeof(tag));
argc -= 2;
argv += 2;
}
if (argc < 2) {
printf("usage: %s", usage);
exit(EXIT_SUCCESS);
}
snprintf(filename, sizeof(filename), "%s/.wtimed/%s", home, tag);
if ((fd = fopen(filename, "r+")) == NULL) {
if ((fd = fopen(filename, "w+")) == NULL) {
fprintf(stderr, "Error while opening data file '%s'.\n", filename);
exit(EXIT_FAILURE);
}
}
if (argv[1][0] != '-') {
fprintf(stderr, "Unknown parameter: %s\n", argv[1]);
} else {
if ((prev_state = cur_state(fd)) == UNKNOWN) {
fprintf(stderr, "Corrupted data file '%s'.\n", filename);
exit(EXIT_FAILURE);
}
switch (argv[1][1]) {
case 'h':
printf("usage: %s", usage);
break;
case 'a':
if (prev_state == STARTED)
fprintf(stderr, "We are allready counting.\n");
else
start_counting(fd);
break;
case 's':
if (prev_state != STARTED)
fprintf(stderr, "We are not counting.\n");
else
stop_counting(fd);
break;
case 'r':
if (argc == 4) { // end
if (strptime(argv[3], "%d-%m-%Y", &tm) == NULL) {
fprintf(stderr, "Malformated end date\n");
exit(EXIT_FAILURE);
}
tm.tm_min = tm.tm_sec = 59;
tm.tm_hour = 23;
rend = mktime(&tm);
} else {
rend = time(NULL);
}
if (argc >= 3) { // start
if (strptime(argv[2], "%d-%m-%Y", &tm) == NULL) {
fprintf(stderr, "Malformated start date\n");
exit(EXIT_FAILURE);
}
tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
rstart = mktime(&tm);
} else { // beginning of month
tnow = time(NULL);
tm = *localtime(&tnow);
tm.tm_mday = 1;
tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
rstart = mktime(&tm);
}
if (rstart > rend) {
fprintf(stderr, "Start date is further then end date.\n");
exit(EXIT_FAILURE);
}
print_report(fd, rstart, rend);
break;
case 'c':
if (prev_state != STARTED) {
fprintf(stderr, "We are not counting.\n");
exit(EXIT_FAILURE);
} else
print_elapsed(fd);
break;
default:
fprintf(stderr, "Unknown parameter: %s\n", argv[1]);
break;
}
}
if (fd)
fclose(fd);
return (0);
}
