static void getitimer_intrinsic (int *wp)
{
struct itimerval it;
if (-1 == getitimer (*wp, &it))
{
SLerrno_set_errno (errno);
SLang_verror (SL_OS_Error, "getitimer failed: %s", SLerrno_strerror (errno));
return;
}
(void) SLang_push_double (timeval_to_double (&it.it_value));
(void) SLang_push_double (timeval_to_double (&it.it_interval));
}
/*
* time_now()
* time in seconds as a double
*/
double time_now(void)
{
struct timeval now;
gettimeofday(&now, NULL);
return timeval_to_double(&now);
}
/*
* time_now()
* time in seconds as a double
*/
double time_now(void)
{
struct timeval now;
if (gettimeofday(&now, NULL) < 0)
return -1.0;
return timeval_to_double(&now);
}
static void perform_ping_test(struct ping_test_recipe recipe,
memcached_st *mst,
struct moxi_stats *out, int *failures)
{
double *timing_results = calloc(recipe.iterations, sizeof(double));
assert(timing_results);
struct timeval timing = { 0, 0 };
char *key = calloc(recipe.keysize, sizeof(char));
assert(key);
char *value = calloc(recipe.valsize, sizeof(char));
assert(value);
/* Key is all 't's...just because */
memset(key, 't', recipe.keysize);
/* Value is a random bunch of stuff */
for (int i = 0; i < recipe.valsize; i++) {
value[i] = random() & 0xff;
}
if (memcached_set(mst,
key, recipe.keysize,
value, recipe.valsize,
0, 0) != MEMCACHED_SUCCESS) {
/* XXX: Failure */
}
for (int i = 0 ; i < recipe.iterations; i++) {
struct timeval tv_pre = { 0, 0 } , tv_post = { 0, 0 };
size_t retrieved_len = 0;
uint32_t flags = 0;
memcached_return error;
gettimeofday(&tv_pre, NULL);
char *retrieved = memcached_get(mst,
key, recipe.keysize,
&retrieved_len, &flags,
&error);
gettimeofday(&tv_post, NULL);
timeval_subtract(&timing, &tv_post, &tv_pre);
timing_results[i] = timeval_to_double(timing);
if (retrieved) {
free(retrieved);
} else {
(*failures)++;
}
}
compute_stats(out, timing_results, recipe.iterations);
free(timing_results);
free(key);
free(value);
}
/*
* [ application_name local_ip local_port cname sdp_file [-t trace_file] ]
*/
int main(int argc, char **argv){
/* create a rtp session, we will assign unique value to identify */
err = rtp_create(&sid);
if (err) {
err_handle(err);
}
sdp_parse(sid, argv); /* parse the sdp file */
/* The application will sleep "rtp_start_time" time if "rtp_start_time" > 0 when the application is start.
*
* NOTE! This is not the same with Start Time in NCTUns
* EX: if the Start Time in NCTUn is 5, and rtp_start_time is 3,
* then the real time to startup the applicaion is 8.
*/
if (rtp_start_time > 0)
usleep( ((int) rtp_start_time * 1000000) );
initial_session(argc, argv, sid); /* set local receive addr, CNAME, and startup the connectoin */
if (is_audio) /* media type is audio */
delay = (ms_pkt / 1000.);
else
delay = (1. / framerate);
err = rtp_get_sour_rtpsocket(sid, &rtp_sockt); /* get source rtp socket */
if (err)
err_handle(err);
err = rtp_get_sour_rtcpsocket(sid, &rtcp_sockt); /* get source rtcp socket */
if (err)
err_handle(err);
if (rtp_sockt > nfds || rtcp_sockt > nfds) {
if (rtp_sockt > rtcp_sockt)
nfds = rtp_sockt;
else
nfds = rtcp_sockt;
}
FD_ZERO(&afds);
FD_ZERO(&rfds);
FD_SET(rtp_sockt, &afds);
FD_SET(rtcp_sockt, &afds);
gettimeofday(&start_tv, NULL);
starttime = (start_tv.tv_sec + start_tv.tv_usec / 1000000.);
now = starttime;
rtp_interval = rtp_stop_time - rtp_start_time;
/* bytes of each packet = ((bits/sample) / 8 ) * (clock rate) * ( each delay of packet in sec ) */
// packet_size = (int) ( (bits_per_sample / 8.) * sampling_rate * delay);
while ((now - starttime) <= rtp_interval) {
memcpy(&rfds, &afds, sizeof(rfds));
err = get_rtcp_timeout(sid, &timeout_tv); /* get the send_rtcp_packet time */
if (err)
err_handle(err);
if (time_expire(&timeout_tv, &now_tv)) {
err = rtp_check_on_expire(); /* rtcp on_expire */
if (err)
err_handle(err);
err = get_rtcp_timeout(sid, &timeout_tv); /* get the send_rtcp_packet time */
if (err)
err_handle(err);
}
nexttime_tv = double_to_timeval(timeval_to_double(timeout_tv) - now);
if (select(nfds + 1, &rfds, (fd_set *)0, (fd_set *)0, &nexttime_tv) < 0) {
if (errno == EINTR)
continue;
else {
printf("nexttime_tv.tv_sec = %ld\n", nexttime_tv.tv_sec);
printf("nexttime_tv.tv_usec = %ld\n", nexttime_tv.tv_usec);
printf("select error: %d\n", errno);
}
}
if (FD_ISSET(rtp_sockt, &rfds)) {
err = on_receive(sid, rtp_sockt, recvbuf, &recbuflen);
if (err)
err_handle(err);
}
else if (FD_ISSET(rtcp_sockt, &rfds)) {
err = on_receive(sid, rtcp_sockt, recvbuf, &recbuflen);
if (err)
err_handle(err);
}
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
} // while ((now - starttime) <= rtp_interval)
err = rtp_close_connection(sid, reason);
if (err) {
err_handle(err);
}
err = rtp_delete(sid);
if (err) {
err_handle(err);
}
return 0;
}
static void setitimer_intrinsic (void)
{
SLang_Ref_Type *interval_ref = NULL, *value_ref = NULL;
int w;
struct itimerval new_value, old_value;
double interval = 0.0, value;
int argc = SLang_Num_Function_Args;
if (SLang_peek_at_stack () == SLANG_REF_TYPE)
{
if (-1 == SLang_pop_ref (&value_ref))
return;
argc--;
if (SLang_peek_at_stack() == SLANG_REF_TYPE)
{
interval_ref = value_ref;
if (-1 == SLang_pop_ref (&value_ref))
goto free_and_return;
argc--;
}
}
switch (argc)
{
case 3:
if (-1 == SLang_pop_double (&interval))
goto free_and_return;
/* drop */
case 2:
default:
if ((-1 == SLang_pop_double (&value))
|| (-1 == SLang_pop_int (&w)))
goto free_and_return;
}
double_to_timeval (interval, &new_value.it_interval);
double_to_timeval (value, &new_value.it_value);
if (-1 == setitimer (w, &new_value, &old_value))
{
SLerrno_set_errno (errno);
SLang_verror (SL_OS_Error, "setitimer failed: %s", SLerrno_strerror (errno));
goto free_and_return;
}
if (value_ref != NULL)
{
value = timeval_to_double (&old_value.it_value);
if (-1 == SLang_assign_to_ref (value_ref, SLANG_DOUBLE_TYPE, &value))
goto free_and_return;
}
if (interval_ref != NULL)
{
interval = timeval_to_double (&old_value.it_interval);
if (-1 == SLang_assign_to_ref (interval_ref, SLANG_DOUBLE_TYPE, &interval))
goto free_and_return;
}
free_and_return:
if (value_ref != NULL)
SLang_free_ref (value_ref);
if (interval_ref != NULL)
SLang_free_ref (interval_ref);
}
int main(int argc, char **argv){
/* setting commad line information */
local_ip = argv[1];
local_port = atoi(argv[2]);
cname = argv[3];
proto = udp;
/* create a rtp session, we will assign unique value to identify */
err = rtp_create(&sid);
if (err) {
err_handle(err);
}
sdp_parse(sid, argv);
if (rtp_start_time > 0) {
usleep( ((int) rtp_start_time * 1000000) );
}
if ((i = initial_session(argc, argv, sid))) {
printf("WARNING : initial_session warning = %d\n", i);
}
else {
printf("initial_session is ok\n");
}
if (is_audio) {
delay = (ms_pkt / 1000.);
}
else {
delay = (1. / framerate); // unit: ms/sec. we assume that 300 samples/frame,
}
/* bytes of each packet = ((bits/sample) / 8 ) * (clock rate) * ( each delay of packet in sec ) */
packet_size = (int) ( bits_per_sample * sampling_rate * delay / 8.);
/* original_bw = min_bw = 50, so we use the same pkt size */
minbw_pktsize = packet_size;
printf("bits_per_sample = %lf, (bits_per_sample/8.) = %lf\n", bits_per_sample, (bits_per_sample/8.));
printf("sampling_rate = %lf\n", sampling_rate);
printf("delay = %lf\n", delay);
printf("packet_size = %d\n", packet_size);
fflush(stdout);
/* the bandwidth wa are using, 30 = frames/sec */
cur_bw = get_cur_bw(packet_size);
err = rtp_get_sour_rtpsocket(sid, &rtp_sockt);
if (err) {
err_handle(err);
}
err = rtp_get_sour_rtcpsocket(sid, &rtcp_sockt);
if (err) {
err_handle(err);
}
if (rtp_sockt > nfds || rtcp_sockt > nfds) {
if (rtp_sockt > rtcp_sockt)
nfds = rtp_sockt;
else
nfds = rtcp_sockt;
}
FD_ZERO(&afds);
FD_ZERO(&rfds);
FD_SET(rtp_sockt, &afds);
FD_SET(rtcp_sockt, &afds);
gettimeofday(&start_tv, NULL);
starttime = (start_tv.tv_sec + start_tv.tv_usec / 1000000.);
nexttime = starttime;
rtp_interval = rtp_stop_time - rtp_start_time;
printf("rtp_interval = %f\n", rtp_interval);
fflush(stdout);
while (rtp_interval >= 0) {
memcpy(&rfds, &afds, sizeof(rfds));
if (RTP_MAX_PKT_SIZE < packet_size){
fprintf(stderr, "RTP_MAX_PKT_SIZE < reads\n");
continue;
}
addtimestamp = ((int) packet_size * (bits_per_sample / 8.) );
err = rtp_send(sid, marker, addtimestamp, codec_num, (int8 *)sendbuf, packet_size);
if (err) {
err_handle(err);
}
marker = 0; /* not the first packet of talkspurt */
rtp_interval -= delay;
nexttime += delay;
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
err = get_rtcp_timeout(sid, &timeout_tv);
if (err) {
err_handle(err);
}
while (now < nexttime) { /* send next packet until now >= nexttime */
//printf("now = %lf\n", now);
//printf("nexttime = %lf\n", nexttime);
if (time_expire(&timeout_tv, &now_tv)) {
err = rtp_check_on_expire();
if (err) {
err_handle(err);
}
err = get_rtcp_timeout(sid, &timeout_tv);
if (err) {
err_handle(err);
}
printf("timeval_to_double(timeout_tv) = %lf\n", timeval_to_double(timeout_tv));
}
/* BECAREFUL, if we disable RTCP, the timeval we get will be 0 */
if (timeval_to_double(timeout_tv) == 0 || nexttime < timeval_to_double(timeout_tv)) {
nexttime_tv = double_to_timeval(nexttime - now);
}
else {
nexttime_tv = double_to_timeval(timeval_to_double(timeout_tv) - now);
}
if (select(nfds + 1, &rfds, (fd_set *)0, (fd_set *)0, &nexttime_tv) < 0) {
if (errno == EINTR)
continue;
else {
printf("nexttime_tv.tv_sec = %ld\n", nexttime_tv.tv_sec);
printf("nexttime_tv.tv_usec = %ld\n", nexttime_tv.tv_usec);
printf("select error: %d\n", errno);
//exit(1);
}
}
if (FD_ISSET(rtp_sockt, &rfds)) {
err = on_receive(sid, rtp_sockt, recvbuf, &recbuflen);
if (err) {
err_handle(err);
}
}
else if (FD_ISSET(rtcp_sockt, &rfds)) {
err = on_receive(sid, rtcp_sockt, recvbuf, &recbuflen);
if (err) {
err_handle(err);
}
adapt_bw(get_recent_recv_loosrate(sid, &ssrc));
}
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
} // while(now < nexttime)
} // while (interval)
err = rtp_close_connection(sid, reason);
if (err) {
err_handle(err);
}
err = rtp_delete(sid);
if (err) {
err_handle(err);
}
return 0;
}
int main(int argc, char **argv){
/* create a rtp session, we will assign unique value to identify */
err = rtp_create(&sid);
if (err) {
err_handle(err);
}
sdp_parse(sid, argv); /* parse the sdp file */
/* The application will sleep "rtp_start_time" time if "rtp_start_time" > 0 when the application is start.
*
* NOTE! This is not the same with Start Time in NCTUns
* EX: if the Start Time in NCTUn is 5, and rtp_start_time is 3,
* then the real time to startup the applicaion is 8.
*/
if (rtp_start_time > 0) {
usleep( ((int) rtp_start_time * 1000000) );
}
initial_session(argc, argv, sid); /* set local receive addr, CNAME, and startup the connectoin */
if (!trans_mode) { /* throughput is static */
if (is_audio) /* media type is audio */
delay = (ms_pkt / 1000.);
else
delay = (1. / framerate);
/* bytes of each packet = ((bits/sample) / 8 ) * (clock rate) * ( each delay of packet in sec ) */
packet_size = (int) ( (bits_per_sample / 8.) * sampling_rate * delay);
if (RTP_MAX_PKT_SIZE < packet_size) {
fprintf(stderr, "The packet size is bigger than RTP_MAX_PKT_SIZE\n");
exit(1);
}
}
/* original_bw = min_bw = 50, so we use the same pkt size */
minbw_pktsize = packet_size;
printf("bits_per_sample = %lf, (bits_per_sample/8.) = %lf\n", bits_per_sample, (bits_per_sample/8.));
printf("sampling_rate = %lf\n", sampling_rate);
printf("delay = %lf\n", delay);
printf("packet_size = %d\n", packet_size);
/* the bandwidth wa are using, 30 = frames/sec */
cur_bw = get_cur_bw(packet_size);
err = rtp_get_sour_rtpsocket(sid, &rtp_sockt);
if (err) {
err_handle(err);
}
err = rtp_get_sour_rtcpsocket(sid, &rtcp_sockt);
if (err) {
err_handle(err);
}
if (rtp_sockt > nfds || rtcp_sockt > nfds) {
if (rtp_sockt > rtcp_sockt)
nfds = rtp_sockt;
else
nfds = rtcp_sockt;
}
FD_ZERO(&afds);
FD_ZERO(&rfds);
FD_SET(rtp_sockt, &afds);
FD_SET(rtcp_sockt, &afds);
gettimeofday(&start_tv, NULL);
starttime = (start_tv.tv_sec + start_tv.tv_usec / 1000000.);
nexttime = starttime;
rtp_interval = rtp_stop_time - rtp_start_time;
printf("rtp_interval = %f\n", rtp_interval);
fflush(stdout);
while (rtp_interval >= 0) {
memcpy(&rfds, &afds, sizeof(rfds));
if (RTP_MAX_PKT_SIZE < packet_size){
fprintf(stderr, "RTP_MAX_PKT_SIZE < reads\n");
continue;
}
addtimestamp = ((int) packet_size * (bits_per_sample / 8.) );
err = rtp_send(sid, marker, addtimestamp, codec_num, (int8 *)sendbuf, packet_size);
if (err) {
err_handle(err);
}
marker = 0; /* not the first packet of talkspurt */
rtp_interval -= delay;
nexttime += delay;
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
err = get_rtcp_timeout(sid, &timeout_tv);
if (err) {
err_handle(err);
}
while (now < nexttime) { /* send next packet until now >= nexttime */
//printf("now = %lf\n", now);
//printf("nexttime = %lf\n", nexttime);
if (time_expire(&timeout_tv, &now_tv)) {
err = rtp_check_on_expire();
if (err) {
err_handle(err);
}
err = get_rtcp_timeout(sid, &timeout_tv);
if (err) {
err_handle(err);
}
printf("timeval_to_double(timeout_tv) = %lf\n", timeval_to_double(timeout_tv));
}
/* BECAREFUL, if we disable RTCP, the timeval we get will be 0 */
if (timeval_to_double(timeout_tv) == 0 || nexttime < timeval_to_double(timeout_tv)) {
nexttime_tv = double_to_timeval(nexttime - now);
}
else {
nexttime_tv = double_to_timeval(timeval_to_double(timeout_tv) - now);
}
if (select(nfds + 1, &rfds, (fd_set *)0, (fd_set *)0, &nexttime_tv) < 0) {
if (errno == EINTR)
continue;
else {
printf("nexttime_tv.tv_sec = %ld\n", nexttime_tv.tv_sec);
printf("nexttime_tv.tv_usec = %ld\n", nexttime_tv.tv_usec);
printf("select error: %d\n", errno);
//exit(1);
}
}
if (FD_ISSET(rtp_sockt, &rfds)) {
err = on_receive(sid, rtp_sockt, recvbuf, &recbuflen);
if (err) {
err_handle(err);
}
}
else if (FD_ISSET(rtcp_sockt, &rfds)) {
err = on_receive(sid, rtcp_sockt, recvbuf, &recbuflen);
if (err) {
err_handle(err);
}
adapt_bw(get_recent_recv_loosrate(sid, &ssrc));
}
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
} // while(now < nexttime)
} // while (interval)
err = rtp_close_connection(sid, reason);
if (err) {
err_handle(err);
}
err = rtp_delete(sid);
if (err) {
err_handle(err);
}
return 0;
}
