version-2

.gitignore

+*.o
+*.txt
+*.png
+simple-client-cpp
+simple-server-cpp

Makefile

+all: simple-server-cpp simple-client-cpp
+
+simple-server-cpp: simple-server-cpp.o
+	g++ -o simple-server-cpp simple-server-cpp.o
+
+simple-client-cpp: simple-client-cpp.o
+	g++ -o simple-client-cpp simple-client-cpp.o
+
+simple-server-cpp.o: simple-server-cpp.cpp
+	g++ -c simple-server-cpp.cpp
+
+simple-client-cpp.o: simple-client-cpp.cpp
+	g++ -c simple-client-cpp.cpp
+
+clean:
+	-rm -f *.o simple-server-cpp simple-client-cpp

expected_output

+1 2 3 4 5 6 7 8 9 10 
\ No newline at end of file

script.sh

+> average_response_time.txt
+> average_throughput.txt
+> average_timeout_rate.txt
+> average_error_rate.txt
+> average_request_sent_rate.txt
+> average_active_threads.txt
+> average_cpu_utilization.txt
+
+if [ $# != 4 ]; then
+    echo "Invalid Usage: loadtest.sh <numClients> <loopNum> <sleepTimeInSeconds> <timeout>"
+fi
+
+ip="127.0.0.1"
+port="5000"
+client_executable="./simple-client-cpp"
+server_executable="./simple-server-cpp"
+
+./$server_executable $port > /dev/null &
+echo $?
+server_pid=$!
+
+for ((j=1; j<=$1;))
+do
+    mkdir client$j
+    client=()
+    pid=()
+
+    watch -n 1 "ps -eLf | grep simple-server-cpp | grep -v grep | wc -l >> ./client$j/activethreads.txt" > /dev/null &
+    watch_pid=$!
+    vmstat 1 > ./client$j/vmstat.txt &
+    vmstat_pid=$!
+    
+    for ((i=1; i<=$j; i++))
+    do
+        this=$(date +%s%N)
+        client+=($this)
+        ./$client_executable $ip:$port test.c $2 $3 $4 > ./client$j/client$this.txt &
+        pid+=($!)
+    done
+
+    for ((i=0; i<$j; i++))
+    do
+        wait ${pid[$i]}
+    done
+
+    $(kill $watch_pid)
+    $(kill $vmstat_pid)
+
+    total_correct_response_rate=0
+    total_total_time=0
+    total_average_response_time=0
+    total_timeout_rate=0
+    total_error_rate=0
+
+    for i in "${client[@]}";
+    do 
+        average_response_time_of_one_client=$(cat ./client$j/client$i.txt | cut -d ' ' -f 1)
+        total_average_response_time=$(echo "$total_average_response_time + $average_response_time_of_one_client" | bc -l)
+        
+        correct_response_rate_of_one_client=$(cat ./client$j/client$i.txt | cut -d ' ' -f 2)
+        total_correct_response_rate=$(echo "$total_correct_response_rate + $correct_response_rate_of_one_client" | bc -l)
+        
+        total_time_of_one_client=$(cat ./client$j/client$i.txt | cut -d ' ' -f 3)
+        total_total_time=$(echo "$total_total_time + $total_time_of_one_client" | bc -l)
+        
+        timeout_rate_of_one_client=$(cat ./client$j/client$i.txt | cut -d ' ' -f 4)
+        total_timeout_rate=$(echo "$total_timeout_rate + $timeout_rate_of_one_client" | bc -l)
+        
+        error_rate_of_one_client=$(cat ./client$j/client$i.txt | cut -d ' ' -f 5)
+        total_error_rate=$(echo "$total_error_rate + $error_rate_of_one_client" | bc -l)
+    done
+
+    average_response_time_of_all_clients=$(echo "$total_average_response_time / $j" | bc -l)
+    average_correct_response_rate_of_all_clients=$(echo "$total_correct_response_rate / $j" | bc -l)
+    average_time_of_all_clients=$(echo "$total_total_time / $j" | bc -l)
+    average_timeout_rate_of_all_clients=$(echo "$total_timeout_rate / $j" | bc -l)
+    average_error_rate_of_all_clients=$(echo "$total_error_rate / $j" | bc -l)
+
+    # echo $j $average_response_time_of_all_clients >> average_response_time.txt
+    # echo $j $average_correct_response_rate_of_all_clients >> average_throughput.txt #goodput
+    # echo $j $average_timeout_rate_of_all_clients >> average_timeout_rate.txt #timeout rate
+    # echo $j $average_error_rate_of_all_clients >> average_error_rate.txt #error rate
+    # request_sent_rate=$(echo "$average_correct_response_rate_of_all_clients+$average_timeout_rate_of_all_clients+$average_error_rate_of_all_clients" | bc -l)
+    # echo $j $request_sent_rate >> average_request_sent_rate.txt #request sent rate
+
+    echo $j $total_average_response_time >> average_response_time.txt
+    echo $j $total_correct_response_rate >> average_throughput.txt #goodput
+    echo $j $total_timeout_rate >> average_timeout_rate.txt #timeout rate
+    echo $j $total_error_rate >> average_error_rate.txt #error rate
+    request_sent_rate=$(echo "$total_correct_response_rate+$total_timeout_rate+$total_error_rate" | bc -l)
+    echo $j $request_sent_rate >> average_request_sent_rate.txt #request sent rate
+
+
+    average_active_threads=$(cat ./client$j/activethreads.txt | awk '{sum+=$1} END {print sum/NR}')
+    echo $j $average_active_threads >> average_active_threads.txt 
+   
+    average_cpu_utilization=$(cat ./client$j/vmstat.txt | awk '{sum+=$15} END {print (((NR-2)*100)-sum)/(NR-2)}')
+    echo $j $average_cpu_utilization >> average_cpu_utilization.txt
+
+    rm -rf ./client$j
+
+    j=$((j+1))
+done
+
+$(kill $server_pid)
+
+
+# Plotting of vmstat.txt using 13th column
+
+cat average_response_time.txt | graph -T png --bitmap-size "1400x1400" -g 3 -L "Clients vs Avg Res Time" -X "Number of Clients" -Y "Avg Res Time (in s)" -r 0.25> ./plot_response_time.png
+cat average_throughput.txt | graph -T png --bitmap-size "1400x1400" -g 3 -L "Clients vs Throughput" -X "Number of Clients" -Y "Throughput (in res/sec)" -r 0.25> ./plot_throughput.png
+cat average_timeout_rate.txt | graph -T png --bitmap-size "1400x1400" -g 3 -L "Clients vs Avg Timeout Rate" -X "Number of Clients" -Y "Avg Timeout Rate" -r 0.25> ./plot_timeout_rate.png
+cat average_error_rate.txt | graph -T png --bitmap-size "1400x1400" -g 3 -L "Clients vs Avg Error Rate" -X "Number of Clients" -Y "Avg Error Rate" -r 0.25> ./plot_error_rate.png
+cat average_request_sent_rate.txt | graph -T png --bitmap-size "1400x1400" -g 3 -L "Clients vs Avg Request Sent Rate" -X "Number of Clients" -Y "Avg Request Sent Rate" -r 0.25> ./plot_request_sent_rate.png
+cat average_active_threads.txt | graph -T png --bitmap-size "1400x1400" -g 3 -L "Clients vs Avg Active Threads" -X "Number of Clients" -Y "Avg Active Threads" -r 0.25> ./plot_active_threads.png
+cat average_cpu_utilization.txt | graph -T png --bitmap-size "1400x1400" -g 3 -L "Clients vs Avg CPU Utilization" -X "Number of Clients" -Y "Avg CPU Utilization" -r 0.25> ./plot_cpu_utilization.png
+
+# rm -rf average_response_time.txt average_throughput.txt average_timeout_rate.txt average_error_rate.txt average_request_sent_rate.txt average_active_threads.txt average_cpu_utilization.txt
\ No newline at end of file

simple-client-cpp.cpp

+#include <iostream>
+
+#include <sys/socket.h> // for socket(), connect(), send(), recv()
+
+#include <string.h> // strtok(), strchr()
+
+#include <unistd.h> // for close()
+
+#include <netdb.h> // for gethostbyname()
+
+#include <fcntl.h> // for O_RDONLY, etc.
+
+#include <cerrno>  // for errno
+#include <cstring> // for strerror
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include <sys/time.h>
+
+#define MAX_TRIES 5
+
+using namespace std;
+
+char *read_from_file(char *);
+char *read_from_server(int, fd_set *, struct timeval *);
+int write_to_server(int, char *);
+
+int timeout_count = 0;
+int error_count = 0;
+
+int main(int argc, char *argv[])
+{
+    // Check for correct number of arguments
+    if (argc != 6)
+    {
+        cerr << "Usage: " << argv[0] << " <hostname:port> filename loopNum sleepTimeSeconds timeout" << endl;
+        return 1;
+    }
+
+    int socket_fd, loopNum = atoi(argv[3]), sleepTimeSeconds = atoi(argv[4]), timeout = atoi(argv[5]);
+    struct sockaddr_in server_address;
+    struct hostent *server;
+    char *hostname = strtok(argv[1], ":");
+    int port = atoi(strtok(NULL, ":"));
+
+    // Get host
+    if ((server = gethostbyname(hostname)) == NULL)
+    {
+        cerr << "Host not found" << endl;
+        return 1;
+    }
+
+    // Set server address
+    memset(&server_address, 0, sizeof(server_address));
+    server_address.sin_family = AF_INET;
+    memcpy(&server_address.sin_addr.s_addr, server->h_addr, server->h_length);
+
+    // Set port
+    server_address.sin_port = htons(port);
+
+    struct timeval t1, t2, t3, t4, timeout_tv;
+    long long int total_time = 0;
+    int correct_responses = 0;
+
+    timeout_tv.tv_sec = timeout;
+    timeout_tv.tv_usec = 0;
+    // setsockopt(socket_fd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout_tv, sizeof(timeout_tv));
+
+    gettimeofday(&t1, NULL);
+    for (int i = 0; i < loopNum; i++)
+    {
+        // Create socket
+        if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+        {
+            cerr << "Socket creation failed: " << strerror(errno) << endl;
+            return 1;
+        }
+
+        fd_set readfds;              // File descriptor set for reading
+        FD_ZERO(&readfds);           // Initialize the set
+        FD_SET(socket_fd, &readfds); // Add your socket to the set
+
+        if (connect(socket_fd, (struct sockaddr *)&server_address, sizeof(server_address)) < 0)
+        {
+            cout << -1 << endl;
+            exit(1);
+        }
+
+        // CONNECTION ESTABLISHED
+        char *c_file_data = read_from_file(argv[2]);
+
+        gettimeofday(&t2, NULL);
+        if (write_to_server(socket_fd, c_file_data) < 0)
+            cerr << "Error in writing data to server: " << strerror(errno) << endl;
+
+        char *response = read_from_server(socket_fd, &readfds, &timeout_tv);
+        if (response != NULL)
+        {
+            correct_responses += 1;
+        }
+        gettimeofday(&t3, NULL);
+
+        // cout << response << endl;
+        sleep(sleepTimeSeconds);
+
+        delete[] c_file_data;
+        delete[] response;
+
+        long long int time1 = (t3.tv_sec - t2.tv_sec) * 1000000 + (t3.tv_usec - t2.tv_usec);
+        total_time += time1;
+        close(socket_fd);
+    }
+    gettimeofday(&t4, NULL);
+    long long int time2 = (t4.tv_sec - t1.tv_sec) * 1000000 + (t2.tv_usec - t1.tv_usec);
+
+    double average_response_time = (double)total_time / (loopNum * 1000000);
+    double throughput = (double)correct_responses * 1000000 / total_time;
+    double loop_time = (double)time2 / 1000000;
+    double timeout_rate = (double)timeout_count * 1000000 / total_time;
+    double error_rate = (double)error_count * 1000000 / total_time;
+
+    cout << average_response_time << " " << throughput << " " << loop_time << " " << timeout_rate << " " << error_count << " " << endl;
+    return 0;
+}
+
+char *read_from_file(char *filename)
+{
+    ifstream file(filename);
+    if (!file.is_open())
+    {
+        cerr << "Error opening file: " << filename << endl;
+        return NULL;
+    }
+
+    file.seekg(0, ios::end);
+    int file_size = file.tellg();
+    file.seekg(0, ios::beg);
+
+    char *file_data = new char[file_size + 1];
+
+    file.read(file_data, file_size);
+    file_data[file_size] = '\0';
+
+    file.close();
+
+    return file_data;
+}
+
+char *read_from_server(int socket_fd, fd_set *readfds, struct timeval *timeout_tv)
+{
+    int len, bytes_read;
+
+    int ready = select(socket_fd + 1, readfds, NULL, NULL, timeout_tv);
+    if (ready == 0)
+    {
+        timeout_count++;
+        return NULL;
+    }
+
+    bytes_read = recv(socket_fd, &len, sizeof(int), 0);
+    char *response = new char[len + 1];
+
+    ready = select(socket_fd + 1, readfds, NULL, NULL, timeout_tv);
+    if (ready == 0)
+    {
+        timeout_count++;
+        return NULL;
+    }
+
+    bytes_read = recv(socket_fd, response, len + 1, 0);
+    return response;
+}
+
+int write_to_server(int socket_fd, char *msg)
+{
+    int len = strlen(msg), bytes_written;
+    bytes_written = send(socket_fd, &len, sizeof(int), 0);
+    bytes_written = send(socket_fd, msg, strlen(msg), 0);
+    return bytes_written;
+}
\ No newline at end of file

simple-server-cpp.cpp

+#include <iostream>
+#include <sys/socket.h> // for socket(), connect(), send(), recv()
+#include <string.h>     // strtok(), strchr()
+#include <unistd.h>     // for close()
+#include <netdb.h>      // for gethostbyname()
+#include <fcntl.h>      // for O_RDONLY, etc.
+#include <cerrno>       // for errno
+#include <cstring>      // for strerror
+#include <sys/time.h>   // for gettimeofday()
+#include <fstream>      // for ifstream
+#include <string>       // for string
+#include <thread>       // for thread
+
+using namespace std;
+
+char *read_from_file(const char *);
+int write_to_file(const char *, char *);
+char *read_from_client(int);
+int write_to_client(int, char *, fd_set *, struct timeval *);
+char *merge(const char *, const char *);
+
+void *worker(void *fd)
+{
+    int socket_fd = *(int *)fd;
+    free(fd);
+    fd = nullptr;
+    cout << "Thread: " << socket_fd << endl;
+    struct timeval t, timeout;
+    timeout.tv_sec = 10;
+    timeout.tv_usec = 0;
+
+    fd_set writefds;              // File descriptor set for reading
+    FD_ZERO(&writefds);           // Initialize the set
+    FD_SET(socket_fd, &writefds); // Add your socket to the set
+
+    gettimeofday(&t, NULL);
+    string time = to_string(t.tv_sec * 1000000 + t.tv_usec);
+
+    string create_dir = "mkdir " + time;
+    string copy_expected_output = "cp expected_output ./" + time;
+    string remove_dir = "rm -r " + time;
+
+    system(create_dir.c_str());
+    system(copy_expected_output.c_str());
+
+    string source_file = "./" + time + "/test.c";
+    string compilation_error_file = "./" + time + "/compilation_error.txt";
+    string runtime_error_file = "./" + time + "/runtime_error.txt";
+    string executable_file = "./" + time + "/test" + time;
+    string output_file = "./" + time + "/output.txt";
+    string expected_output_file = "./" + time + "/expected_output";
+    string diff_output_file = "./" + time + "/diff.txt";
+
+    char *c_file_data = read_from_client(socket_fd);
+    if (c_file_data == NULL)
+    {
+        cerr << "Error in reading data from client: " << strerror(errno) << endl;
+        exit(1);
+    }
+
+    if (write_to_file(source_file.c_str(), c_file_data) < 0)
+    {
+        cerr << "Error in writing data to file: " << strerror(errno) << endl;
+        exit(1);
+    }
+
+    char *reply = new char[1024];
+
+    string compilation_command = "gcc -o " + executable_file + " " + source_file + " 2> " + compilation_error_file;
+    string run_command = "sh -c ./" + executable_file + " > " + output_file + " 2> " + runtime_error_file;
+    string diff_command = "diff " + output_file + " " + expected_output_file + " > " + diff_output_file;
+
+    if (system(compilation_command.c_str()) == 0)
+    {
+        if (system(run_command.c_str()) != 0)
+        {
+            reply = merge("RUNTIME ERROR", runtime_error_file.c_str());
+        }
+        else
+        {
+            if (system(diff_command.c_str()) == 0)
+            {
+                reply = merge("PASS", output_file.c_str());
+            }
+            else
+            {
+                string merge_diff_output_command1 = "echo '\n' >> " + output_file;
+                string merge_diff_output_command2 = "cat " + diff_output_file + " >> " + output_file;
+                system(merge_diff_output_command1.c_str());
+                system(merge_diff_output_command2.c_str());
+                reply = merge("OUTPUT ERROR", output_file.c_str());
+            }
+        }
+    }
+    else
+    {
+        reply = merge("COMPILiER ERROR", compilation_error_file.c_str());
+    }
+
+    cout << reply << endl;
+    if (write_to_client(socket_fd, reply, &writefds, &timeout) == -2) // Timeout
+        ;
+
+    delete[] c_file_data;
+    delete[] reply;
+    system(remove_dir.c_str());
+    close(socket_fd);
+    pthread_exit(NULL);
+    return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+    // Check for correct number of arguments
+    if (argc != 2)
+    {
+        cerr << "Usage: " << argv[0] << " port" << endl;
+        return 1;
+    }
+
+    int socket_listen_fd;
+    struct sockaddr_in server_address, client_address;
+    socklen_t client_addr_length = sizeof(client_address);
+
+    // Set server address
+    memset(&server_address, 0, sizeof(server_address));
+    server_address.sin_family = AF_INET;
+    server_address.sin_addr.s_addr = INADDR_ANY;
+    server_address.sin_port = htons(atoi(argv[1]));
+
+    // Create socket
+    if ((socket_listen_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+    {
+        cerr << "Socket creation failed: " << strerror(errno) << endl;
+        return 1;
+    }
+
+    // Connect socket
+    if (bind(socket_listen_fd, (struct sockaddr *)&server_address, sizeof(server_address)) < 0)
+        cerr << "Error on binding: " << strerror(errno) << endl;
+
+    // Listening
+    listen(socket_listen_fd, 500);
+
+    while (1)
+    {
+        int *socket_fd = (int *)malloc(sizeof(int));
+        if ((*socket_fd = accept(socket_listen_fd, (struct sockaddr *)&client_address, &client_addr_length)) < 0)
+            cerr << "Error on accepting: " << strerror(errno) << endl;
+
+        cout << "Main: " << *socket_fd << endl;
+        // CONNECTION ESTABLISHED
+        pthread_t t;
+        if (pthread_create(&t, NULL, &worker, socket_fd) < 0)
+        {
+            cerr << "Error in creating thread: " << strerror(errno) << endl;
+        }
+        // pthread_detach(t);
+
+        // std::thread t1(worker, (void *)socket_fd);
+        // t1.detach();
+    }
+    close(socket_listen_fd);
+
+    return 0;
+}
+
+char *read_from_file(const char *filename)
+{
+    ifstream file(filename);
+    if (!file.is_open())
+    {
+        cerr << "Error opening file: " << filename << endl;
+        return NULL;
+    }
+
+    file.seekg(0, ios::end);
+    int file_size = file.tellg();
+    file.seekg(0, ios::beg);
+
+    char *file_data = new char[file_size + 1];
+
+    file.read(file_data, file_size);
+    file_data[file_size] = '\0';
+
+    file.close();
+
+    return file_data;
+}
+
+int write_to_file(const char *filename, char *data)
+{
+    int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+    if (fd < 0)
+    {
+        cerr << "Error opening file: " << strerror(errno) << endl;
+        return -1;
+    }
+
+    int bytes_written = write(fd, data, strlen(data));
+    if (bytes_written < 0)
+    {
+        cerr << "Error writing to file: " << strerror(errno) << endl;
+        close(fd);
+        return -1;
+    }
+    close(fd);
+    return bytes_written;
+}
+
+char *read_from_client(int socket_fd)
+{
+    int len;
+    int bytes_read = recv(socket_fd, &len, sizeof(int), 0);
+    if (bytes_read == 0)
+        return NULL;
+    char *c_file_data = new char[len + 1];
+
+    memset(c_file_data, 0, len + 1);
+    bytes_read = recv(socket_fd, c_file_data, len + 1, 0);
+    if (bytes_read == 0)
+        return NULL;
+    return c_file_data;
+}
+
+int write_to_client(int socket_fd, char *msg, fd_set *writefds, struct timeval *timeout)
+{
+    int len = strlen(msg);
+
+    int ready = select(socket_fd + 1, NULL, writefds, NULL, timeout);
+    if (ready == 0)
+        return -2;
+    int bytes_written = send(socket_fd, &len, sizeof(int), 0);
+    if (bytes_written < 0)
+        cerr << "Error in writing data to client: " << strerror(errno) << endl;
+
+    ready = select(socket_fd + 1, NULL, writefds, NULL, timeout);
+    if (ready == 0)
+        return -2;
+    bytes_written = send(socket_fd, msg, strlen(msg) + 1, 0);
+    if (bytes_written < 0)
+        cerr << "Error in writing data to client: " << strerror(errno) << endl;
+    return bytes_written;
+}
+
+char *merge(const char *msg, const char *filename)
+{
+    char *data = read_from_file(filename);
+    if (strcmp(msg, "PASS") == 0)
+    {
+        char *buffer = new char[strlen(msg) + 2];
+        strcpy(buffer, msg);
+        return buffer;
+    }
+    char *buffer = new char[strlen(data) + strlen(msg) + 2];
+    strcpy(buffer, msg);
+    strcat(buffer, "\n");
+    strcat(buffer, data);
+
+    delete[] data;
+    delete[] msg;
+    delete[] filename;
+    return buffer;
+}

test.c

+#include <stdio.h>
+int main()
+{
+    int arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    int i, j, temp;
+
+    for (i = 0; i < n - 1; i++)
+    {
+        for (j = 0; j < n - i - 1; j++)
+        {
+            if (arr[j] > arr[j + 1])
+            {
+                temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+            }
+        }
+    }
+
+    for (i = 0; i < n; i++)
+    {
+        printf("%d ", arr[i]);
+    }
+
+    return 0;
+}
\ No newline at end of file