void leimkuhler_tree(double maxtime)
{
int i;
const double tinterval = 1.0;
float time_start, time_end;
if (verbosity > 0)
{
fprintf(err, "Using leimkuhler_tree integrator.\n"
"TIME_CAP: %3i\n",
TIME_CAP);
fprintf(err, "-------------------------------------------------\n");
}
/*========================================================================
* Calculate the initial forces and time steps, start the integrator
* by first drifting.
*======================================================================*/
for (i=0; i < NPARTICLES; i++)
lkACCEL_AND_POTENTIAL(ps[i], 0);
for (i=0; i < NPARTICLES; i++)
{
double h2 = sqrt(SELECT_TIME_STEP(ps[i]));
DRIFT(ps[i], h2);
ps[i]->time = 0;
ps[i]->timeNext = h2;
}
write_state(0);
/*========================================================================
* Put each particle into the priority queue
*======================================================================*/
struct pqNode *head = ps[0];
for (i=1; i < NPARTICLES; i++)
{
struct pqNode *p = ps[i];
PQ_MERGE(head, p);
}
pTree *tree;
tree = pintBuildTree(ps, NULL);
#if 1
time_start = CPUTIME;
for (i=0; i < 50000; i++)
tree = pintBuildTree(ps, NULL);
time_end = CPUTIME;
#endif
#if DYNAMIC_TREE
//fprintf(err, "tree->cell.fMass = %e\n", tree->cell.fMass);
#endif
fprintf(err, "comparisonCount = %i\n", comparisonCount);
fprintf(err, "nodeCount = %i\n", nodeCount);
fprintf(err, "tree construction time = %e\n", (time_end - time_start) / 50000.);
//fprintf(err, "tree construction time = %e\n", (time_end - time_start) );
//assert(tree->cell.fMass == 1.0);
#if 0
#if DYNAMIC_TREE
int len = walk_tree(tree, NULL, 0);
fprintf(err, "\n");
#else
int len = walk_tree(tree, ps, 0);
fprintf(err, "\n");
#endif
#endif
#if 0
#if DYNAMIC_TREE
fprintf(err, "\n\n");
struct pqNode **ps2 = (struct pqNode **)malloc(NPARTICLES * sizeof(struct pqNode *));
int len = walk_tree(tree, ps2, 0);
fprintf(err, "len = %i\n", len);
assert(len == NPARTICLES);
struct pqNode *ps3 = (struct pqNode *)malloc(NPARTICLES * sizeof(struct pqNode));
assert(ps3 != NULL);
for (i=0; i < NPARTICLES; i++)
memcpy(&(ps3[i]), ps2[i], sizeof(struct pqNode));
for (i=0; i < NPARTICLES; i++)
ps2[i] = &(ps3[i]);
time_start = CPUTIME;
for (i=0; i < 5000; i++)
tree = pintBuildTree(ps2, NULL);
time_end = CPUTIME;
fprintf(err, "tree->cell.fMass = %e\n", tree->cell.fMass);
fprintf(err, "tree construction time = %e\n", (time_end - time_start) / 5000.);
#endif
#endif
//assert(tree->cell.fMass == 1.0);
return;
/*========================================================================
* Run the simulation
*======================================================================*/
double prevtimeNext = 0;
double tout = tinterval;
fflush(out);
fflush(err);
RESET_ACCEL_HIST();
while (1)
{
struct pqNode *p;
PQ_REMOVE_MIN(head, p);
assert(prevtimeNext <= p->timeNext);
prevtimeNext = p->timeNext;
fprintf(out, "%i %f %f %f\n", p->id, p->r[0], p->r[1], p->r[2]);
fflush(out);
/*====================================================================
* Write output
*==================================================================*/
if (p->timeNext < tout && tout <= head->timeNext)
{
tout += tinterval;
RESET_ACCEL_HIST();
for (i=0; i < NPARTICLES; i++) ACCEL_HIST(ps[i]->a);
write_state(p->timeNext);
AccelCount = 0;
if (p->timeNext < maxtime && maxtime <= head->timeNext) break;
#if !DYNAMIC_TREE
//tree = pintBuildTree2(ps, tree);
tree = pintBuildTree(ps, NULL);
#endif
}
/*====================================================================
* Drift, Kick, Drift
*==================================================================*/
double h1 = p->timeNext - p->time;
DRIFT(p, h1);
lkACCEL_AND_POTENTIAL(p, p->timeNext);
KICK(p, h1);
double h2 = SELECT_TIME_STEP(p) / h1;
KICK(p, h2);
DRIFT(p, h2);
/*====================================================================
* Update particle's time and put it back in the queue
*==================================================================*/
p->time = p->timeNext + h2;
p->timeNext = p->time + h2;
#if DYNAMIC_TREE
_DA_ time_start = CPUTIME;
tree = tree_update(p, tree);
_DA_ time_end = CPUTIME;
_DA_ fprintf(err, "tree update time = %e\n", time_end - time_start);
#endif
#if 0
#if DYNAMIC_TREE
_DA_ time_start = CPUTIME;
tree = tree_insert(p, tree);
_DA_ time_end = CPUTIME;
_DA_ fprintf(err, "tree insert time = %e\n", time_end - time_start);
#endif
#endif
PQ_MERGE(head, p);
}
}
int main(int argc, char *argv[])
{
char buffer[MAX_PACKET_SIZE];
static struct sockaddr_in addr;
int rc, i, count;
struct timeval t1, t2, dt;
KICK(argc < 3, "incorrect usage\n"
"Usage:\n"
"./linphone_proxy <local_ip> <remote_ip>\n");
local_ip = argv[1];
remote_ip = argv[2];
add_poll(&fds[0], STDIN_FILENO);
proxy_to_linphone_socket = create_socket(SOCK_DGRAM, SIP_LINPHONE);
init_sockaddr(&proxy_to_linphone_addr, "127.0.0.1", SIP_PORT);
add_poll(&fds[1], proxy_to_linphone_socket);
eprintf("created proxy_to_linphone SIP socket SRC:localhost:%d - DST:localhost:%d\n",
SIP_LINPHONE, SIP_PORT);
proxy_to_proxy_socket = create_socket(SOCK_DGRAM, SIP_PROXY);
init_sockaddr(&proxy_to_proxy_addr, remote_ip, SIP_PROXY);
add_poll(&fds[2], proxy_to_proxy_socket);
eprintf("created proxy_to_sip SIP socket SRC:localhost:%d - DST:%s:%d\n",
SIP_PROXY, remote_ip, SIP_PROXY);
proxy_to_linphone_data_socket = create_socket(SOCK_DGRAM, DATA_LINPHONE);
init_sockaddr(&proxy_to_linphone_data_addr, "127.0.0.1", DATA_PORT);
add_poll(&fds[3], proxy_to_linphone_data_socket);
eprintf("created proxy_to_linphone DATA socket SRC:localhost:%d - DST:localhost:%d\n",
DATA_LINPHONE, DATA_PORT);
proxy_to_proxy_data_socket = create_socket(SOCK_DGRAM, DATA_PROXY);
init_sockaddr(&proxy_to_proxy_data_addr, remote_ip, DATA_PROXY);
add_poll(&fds[4], proxy_to_proxy_data_socket);
eprintf("created proxy_to_proxy DATA socket SRC:localhost:%d - DST:%s:%d\n",
DATA_PROXY, remote_ip, DATA_PROXY);
manager_socket = create_socket(SOCK_DGRAM, MANAGER_PORT);
init_sockaddr(&manager_addr, "0.0.0.0", MANAGER_PORT);
add_poll(&fds[5], manager_socket);
eprintf("created manager socket SRC:localhost:%d - DST:0.0.0.0:0\n",
MANAGER_PORT);
while (1) {
rc = poll(fds, NUM_FDS, -1);
DIE(-1 == rc, "poll");
for (i = 0; i < NUM_FDS; i++) {
if (0 == fds[i].revents) {
continue;
}
switch(i) {
/* receive line from console */
case 0:
break;
/* receive SIP packet from linphone */
case 1:
gettimeofday_safe(&t1);
count = recv_msg(fds[i].fd, &proxy_to_linphone_addr, buffer);
if (begins_with(buffer, "INVITE")) {
copy_packet(&out_invite, buffer, count);
//printf("captured INVITE packet:\n%s\n", out_invite.buffer);
} else if (begins_with(buffer, "ACK")) {
copy_packet(&out_ack, buffer, count);
//printf("captured ACK packet:\n%s\n", out_ack.buffer);
} else if (strstr(buffer, "200 OK") && strstr(buffer, "OPTIONS" )) {
copy_packet(&out_op_ok, buffer, count);
//printf("captured OPTIONS OK packet:\n%s\n", out_op_ok.buffer);
}
send_msg(proxy_to_proxy_socket, &proxy_to_proxy_addr, buffer, count);
gettimeofday_safe(&t2);
time_diff(&t1, &t2, &dt);
printf("time case 1: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
break;
/* receive SIP packet from proxy */
case 2:
gettimeofday_safe(&t1);
count = recv_msg(fds[i].fd, &addr, buffer);
send_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr, buffer, count);
gettimeofday_safe(&t2);
time_diff(&t1, &t2, &dt);
printf("time case 2: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
break;
/* receive data packet from linphone */
case 3:
gettimeofday_safe(&t1);
count = recv_msg(fds[i].fd, &proxy_to_linphone_data_addr, buffer);
send_msg(proxy_to_proxy_data_socket, &proxy_to_proxy_data_addr, buffer, count);
gettimeofday_safe(&t2);
time_diff(&t1, &t2, &dt);
printf("time case 3: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
break;
/* receive data packet from proxy */
case 4:
gettimeofday_safe(&t1);
count = recv_msg(fds[i].fd, &addr, buffer);
send_msg(proxy_to_linphone_data_socket, &proxy_to_linphone_data_addr, buffer, count);
gettimeofday_safe(&t2);
time_diff(&t1, &t2, &dt);
printf("time case 4: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
break;
/* receive command from manager */
case 5:
count = recv_msg(fds[i].fd, &manager_addr, buffer);
if (begins_with(buffer, "IP: ")) {
while (!isdigit(buffer[count - 1])) {
buffer[--count] = 0;
}
strcpy(migrate_ip, buffer + 4);
migrate_init();
} else if (begins_with(buffer, "establish")) {
migrate_establish();
} else if (begins_with(buffer, "redirect: ")) {
while (!isdigit(buffer[count - 1])) {
buffer[--count] = 0;
}
strcpy(redirect_ip, buffer + 10);
migrate_redirect();
}
break;
/* error */
default:
break;
}
}
}
return EXIT_SUCCESS;
}
