void *batch(void* arg) {
int execution = (int)arg;
Linked_list *threads, *node;
int ret, matches, req_count=0;
unsigned long delay;
pthread_t *t1;
threads = createList(NULL, NULL);
do {
req_count++;
//fprintf(stderr, "will scanf\n");
matches = fscanf(fd, "%lu\n", &delay);
fprintf(stderr, "%lu waiting %ld\n", time_millis(), delay);
usleep(delay);
t1 = malloc(sizeof(pthread_t));
ret = pthread_create(t1, NULL, request, (void *) &delay);
if (ret != 0)
fprintf(stderr, "ERROR creating request thread %i\n", ret);
else
insertAfter(t1, threads);
} while (matches != EOF && req_count < MAX_REQ);
hasnext = matches != EOF;
sem_post(sem);
for(node = threads->next; node != NULL; node = node->next) {
fprintf(stderr, "%lu join request %d ", time_millis(), execution);
t1 = (pthread_t*)(node->value);
fprintf(stderr, "%ld\n", t1);
pthread_join(*t1, NULL);
}
return (void*)&matches;
}
void *request(void* arg) {
unsigned long delay = *((unsigned*)arg);
long st, duration;
int sock, reply;
counter++;
st = time_millis();
sock = connectTo(load_balancer, PORT_LB);
write(sock, &counter, sizeof(int));
read(sock, &reply, sizeof(int));
close(sock);
duration = time_millis() - st;
printf("%ld %lu %ld %d\n", st, delay, duration, reply);
}
/**
* Pause the program for some specified amount of time.
* SLEEP <milliseconds>
*/
void cmd_sleep(char *args) {
static unsigned long delay;
static unsigned long sleep_end_millis;
if (isdigit(args[0])) {
sscanf(args, "%ul", &delay);
sleep_end_millis = time_millis() + delay;
while (time_millis() < sleep_end_millis) {
if (is_interrupted()) {
break;
}
}
} else {
syntax_error();
}
}
int main(int argc, char *argv[]) {
int workers_n = atoi(argv[1]); //number of workers
char *hostnames = argv[2]; //comma separated list of workers' hostnames
int iteration = atoi(argv[3]); // iteration counter.
char *token; //for hosts tokenization
char* hosts[workers_n], *host_name; //workers' socket names
int sock; //socket descriptor
int data;
pid_t pid;
int listenfd = 0, connfd = 0, counter = 0;
struct sockaddr_in serv_addr;
long st, et;
data = 0;
token = strtok(hostnames, ",");
while (token != NULL ) {
hosts[data++] = token;
token = strtok(NULL, ",");
}
socketlisten(&listenfd, atoi(PORT_LB));
fflush(stdout);
while (1) {
host_name = hosts[counter];
counter = counter == workers_n - 1 ? 0 : counter + 1;
fprintf(stderr, "next worker: %s\n", host_name);
connfd = accept(listenfd, (struct sockaddr*) NULL, NULL );
if (!(pid = fork())) {
fprintf(stderr, "connection at %ld\n", time_millis());
st = time_millis();
read(connfd, &data, sizeof(data));
sock = connectTo(host_name, PORT, "to worker");
write(sock, &data, sizeof(data));
read(sock, &data, sizeof(data));
write(connfd, &data, sizeof(data));
et = time_millis();
fprintf(stdout, "%d %ld %ld %s\n", iteration, st, et, host_name);
return 0;
} else {
if (pid == -1)
fprintf(stderr, "ERROR creating process: %d\n", errno);
}
}
}
void verify_num_workers() {
double requests_per_worker = (double)load/num_workers;
fprintf(stderr, "%ld requests per worker %f\n", time_millis(), requests_per_worker);
if (requests_per_worker >= limit_max)
request_workers(pool_manager, 1);
else if (requests_per_worker <= limit_min && num_workers > 1)
release_workers(pool_manager, -1);
}
int main(int argc, char* argv[]) {
load_balancer = argv[1];
char* file_name = argv[2];
int ret, counter=0;
pthread_t *t1;
Linked_list *threads, *node;
sem = createsemaphore("/sem_trace", 0);
threads = createList(NULL, NULL);
fd = fopen(file_name,"r");
if (fd == NULL) {
fprintf(stdout, "Error opening file %s\n", file_name);
exit(1);
}
fprintf(stderr, "opened file %d\n", fd);
do {
counter++;
fprintf(stderr, "%lu new batch\n", time_millis());
t1 = malloc(sizeof(pthread_t));
ret = pthread_create(t1, NULL, batch, (void*)counter);
if (ret != 0)
fprintf(stderr, "ERROR creating batch thread %i\n", ret);
else
insertAfter(t1, threads);
sem_wait(sem);
} while (hasnext);
fclose(fd);
fprintf(stderr, "%lu workload finished\n", time_millis());
for(node = threads->next; node != NULL; node = node->next) {
fprintf(stderr, "%lu join batch", time_millis());
t1 = (pthread_t*)(node->value);
fprintf(stderr, "%ld\n", t1);
pthread_join(*t1, NULL);
}
}
bool MulticastSender::SendUDPMessage(const std::string& msg, std::vector<std::string>* responses, unsigned int timeout, unsigned int max_response_count, CheckResponseCallback check_response_callback/* = NULL*/, void* check_response_callback_arg/* = NULL*/)
{
int mcast_receive_socket=-1;
bool retval=false;
int cnt;
struct sockaddr_in sa_mcast_server;
struct sockaddr_in sa_mcast_group;
struct sockaddr_in sa_broadcast;
unsigned long abs_rx_timeout;
memset(&sa_mcast_server, 0, sizeof(struct sockaddr_in));
memset(&sa_mcast_group, 0, sizeof(struct sockaddr_in));
memset(&sa_broadcast, 0, sizeof(struct sockaddr_in));
sa_mcast_server.sin_family = AF_INET;
sa_mcast_server.sin_port = htons(port);
sa_mcast_server.sin_addr.s_addr = htonl(INADDR_ANY);
sa_mcast_group.sin_family = AF_INET;
sa_mcast_group.sin_port = htons(port);
sa_mcast_group.sin_addr.s_addr = inet_addr(group.c_str());
sa_broadcast.sin_family = AF_INET;
sa_broadcast.sin_port = htons(port);
sa_broadcast.sin_addr.s_addr = INADDR_BROADCAST;
std::vector<in_addr> own_addresses = GetOwnAddresses();
mcast_receive_socket = socket(PF_INET, SOCK_DGRAM, 0);
int yes=1;
setsockopt(mcast_receive_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes));
if (bind(mcast_receive_socket, (struct sockaddr *)&sa_mcast_server, sizeof(struct sockaddr_in)) < 0)
{
perror("bind");
goto cleanup;
}
if( use_broadcast || sa_mcast_group.sin_addr.s_addr == INADDR_BROADCAST ){
if (setsockopt(mcast_receive_socket, SOL_SOCKET, SO_BROADCAST, (const char*)&yes, sizeof(yes)) < 0)
{
perror("setsockopt - SO_BROADCAST");
goto cleanup;
}
}
if( sa_mcast_group.sin_addr.s_addr != INADDR_BROADCAST ){
struct ip_mreq imr;
imr.imr_multiaddr.s_addr = inet_addr(group.c_str());
for(unsigned int i=0; i<own_addresses.size(); i++)
{
imr.imr_interface.s_addr = own_addresses[i].s_addr;
if (setsockopt(mcast_receive_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *) &imr, sizeof(struct ip_mreq)) < 0)
{
printf("Add multicast membership failed for interface %s", inet_ntoa(own_addresses[i]));
}
}
}
for(unsigned int i=0; i<own_addresses.size(); i++)
{
int send_socket = socket(PF_INET, SOCK_DGRAM, 0);
setsockopt(send_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes));
if( use_broadcast )setsockopt(send_socket, SOL_SOCKET, SO_BROADCAST, (const char*)&yes, sizeof(yes));
sa_mcast_server.sin_addr.s_addr = own_addresses[i].s_addr;
if (bind(send_socket, (struct sockaddr *)&sa_mcast_server, sizeof(struct sockaddr_in)) < 0)
{
perror("bind");
closesocket(send_socket);
goto cleanup;
}
struct sockaddr* so_addr=(struct sockaddr *)(use_broadcast?&sa_broadcast:&sa_mcast_group);
int n = sendto(send_socket, msg.c_str(), msg.size(), 0, so_addr, sizeof(struct sockaddr_in) );
if (n < 0) {
perror("sendto");
closesocket(send_socket);
goto cleanup;
}
closesocket(send_socket);
}
responses->clear();
abs_rx_timeout=time_millis()+timeout;
while ( responses->size() < max_response_count) {
unsigned long now=time_millis();
if((long)(now-abs_rx_timeout) >= 0)break;
struct timeval wait_time;
wait_time.tv_sec=(abs_rx_timeout-now)/1000;
wait_time.tv_usec=((abs_rx_timeout-now)%1000)*1000;
fd_set inFd, outFd, excFd;
FD_ZERO(&inFd);
FD_ZERO(&outFd);
FD_ZERO(&excFd);
int maxFd = mcast_receive_socket;
FD_SET(mcast_receive_socket, &inFd);
int n_events=select(maxFd+1, &inFd, &outFd, &excFd, &wait_time);
if(n_events < 0)
{
perror("select");
goto cleanup;
}
if(n_events>0){
char* rx_buffer=new char[UDP_RX_BUFFER_SIZE];
socklen_t len_r;
len_r = sizeof(struct sockaddr_in);
cnt = recv(mcast_receive_socket, rx_buffer, UDP_RX_BUFFER_SIZE, 0);
if (cnt < 0) {
perror("recvfrom");
delete[] rx_buffer;
goto cleanup;
}
std::string response(rx_buffer, cnt);
if((response.size() != msg.size()) || (response.compare(msg)!=0)){
if( check_response_callback )
{
if( check_response_callback(check_response_callback_arg, response))responses->push_back(response);
}else{
responses->push_back(response);
}
}
delete[] rx_buffer;
}
}
retval=true;
cleanup:
if(mcast_receive_socket>=0)closesocket(mcast_receive_socket);
return retval;
}
int main(int argc, char *argv[]) {
int clients = atoi(argv[1]); //simultaneous clients
int requests = atoi(argv[2]); // requests per client
char* st = argv[3]; //workload per request. just to print
char* load_balancer = argv[4]; //name of the node that must receive the requests
char* workers_n = argv[5]; //number of workers. not used. just to print
char* workers_p = argv[6]; //not user. just to print
char* contention = argv[7]; //not user. just to print
char* coherency = argv[8];
char* counter = argv[9];
int sock; //socket descriptor
int msg, reply; //reply from load balancer
int i, j; //loop iterators
long start_time, elapsed_time;
float throughput;
pid_t pid;
fprintf(stderr,"%ld starting warmup\n", time_millis());
for (i = 0; i < clients; i++) {
usleep(100);
if (!(pid = fork())) {
//for (j = 0; j < requests; j++) {
//start_time = time_millis();
//fprintf(stderr, "connecting to %s\n", load_balancer);
sock = connectTo(load_balancer, PORT_LB, "warmup");
//send request
msg = i*100+j;
//fprintf(stderr,"sending request %d %d\n", i, j);
write(sock, &msg, sizeof(int));
//fprintf(stderr,"sent request %d %d\n", i, j);
//wait for completion
read(sock, &reply, sizeof(int));
close(sock);
//elapsed_time = time_millis() - start_time;
//printf("%d %d %d %s %s %s %s %s %ld %ld %s\n", i + 1, j + 1,
// requests, st, workers_n, workers_p, contention, coherency, elapsed_time, start_time, counter);
//}
return 0;
}/* else {
if (pid == -1)
fprintf(stderr, "ERROR creating process: %d\n", errno);
}*/
}
for (i = 0; i < clients; i++)
wait(NULL );
fprintf(stderr, "%ld starting requests\n", time_millis());
for (i = 0; i < clients; i++) {
usleep(100);
if (!(pid = fork())) {
for (j = 0; j < requests; j++) {
start_time = time_millis();
fprintf(stderr, "connecting to %s\n", load_balancer);
sock = connectTo(load_balancer, PORT_LB, "trace");
//send request
msg = i*100+j;
fprintf(stderr,"sending request %d %d\n", i, j);
write(sock, &msg, sizeof(int));
fprintf(stderr,"sent request %d %d\n", i, j);
//wait for completion
read(sock, &reply, sizeof(int));
close(sock);
elapsed_time = time_millis() - start_time;
printf("%d %d %d %s %s %s %s %s %ld %ld %s\n", i + 1, j + 1,
requests, st, workers_n, workers_p, contention, coherency, elapsed_time, start_time, counter);
}
return 0;
} else {
if (pid == -1)
fprintf(stderr, "ERROR creating process: %d\n", errno);
}
}
for (i = 0; i < clients; i++)
wait(NULL );
}
