main.cpp - master - engorgen/speed_test_connection_technical_specification

main.cpp
143 строки7 KB
engorgen
final version
29 янв 2025, 12:08
29 янв 2025, 12:0878cb298
#include <iostream>
#include <fstream>
#include <chrono>
#include <thread>
#include <vector>
#include <cstring>
#include <numeric>
#include <arpa/inet.h>
#include <unistd.h>

using namespace std;
using namespace chrono;

void run_server(int port, size_t packet_size, size_t num_packets) {
    int server_socket = socket(AF_INET, SOCK_DGRAM, 0);
    if (server_socket < 0) {
        cerr << "Ошибка: не удалось создать сокет." << endl;
        exit(EXIT_FAILURE);
    }
    sockaddr_in server_address{};
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = INADDR_ANY;
    server_address.sin_port = htons(port);
    if (::bind(server_socket, (struct sockaddr*)&server_address, sizeof(server_address)) < 0) {
        cerr << "Ошибка: не удалось привязать сокет к адресу." << endl;
        close(server_socket);
        exit(EXIT_FAILURE);
    }
    char* buffer = new char[packet_size];
    sockaddr_in client_address{};
    socklen_t client_address_len = sizeof(client_address);
    cout << "Сервер запущен и ожидает пакеты..." << endl;
    for (size_t i = 0; i < num_packets; ++i) {
        recvfrom(server_socket, buffer, packet_size, 0, (struct sockaddr*)&client_address, &client_address_len);
        sendto(server_socket, buffer, packet_size, 0, (struct sockaddr*)&client_address, client_address_len);
    }
    delete[] buffer;
    close(server_socket);
    cout << "Сервер завершил работу." << endl;
}

void run_client(const string& server_ip, int port, size_t packet_size, size_t num_packets, int interval_ms, const string& output_file) {
    int client_socket = socket(AF_INET, SOCK_DGRAM, 0);
    if (client_socket < 0) {
        cerr << "Ошибка: не удалось создать сокет." << endl;
        exit(EXIT_FAILURE);
    }
    sockaddr_in server_address{};
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(port);
    if (inet_pton(AF_INET, server_ip.c_str(), &server_address.sin_addr) <= 0) {
        cerr << "Ошибка: неверный IP-адрес сервера." << endl;
        close(client_socket);
        exit(EXIT_FAILURE);
    }
    char* buffer = new char[packet_size];
    memset(buffer, 'A', packet_size);
    vector<double> round_trip_times;
    vector<double> one_way_times;
    cout << "Клиент запущен. Отправка пакетов на сервер..." << endl;
    auto start_time_for_throughput = high_resolution_clock::now();
    for (size_t i = 0; i < num_packets; ++i) {
        auto start_time = high_resolution_clock::now();
        sendto(client_socket, buffer, packet_size, 0, (struct sockaddr*)&server_address, sizeof(server_address));
        recvfrom(client_socket, buffer, packet_size, 0, nullptr, nullptr);
        auto end_time = high_resolution_clock::now();
        double round_trip_time = duration_cast<microseconds>(end_time - start_time).count();
        double one_way_time = round_trip_time / 2.0;
        round_trip_times.push_back(round_trip_time);
        one_way_times.push_back(one_way_time);
        this_thread::sleep_for(milliseconds(interval_ms));
    }
    auto end_time_for_throughput = high_resolution_clock::now();
    auto total_time = duration_cast<microseconds>(end_time_for_throughput - start_time_for_throughput).count() / 1e6;

    double throughput = (num_packets * packet_size * 8) / total_time;
    double avg_round_trip_time = accumulate(round_trip_times.begin(), round_trip_times.end(), 0.0) / round_trip_times.size();
    double avg_one_way_time = accumulate(one_way_times.begin(), one_way_times.end(), 0.0) / one_way_times.size();

    ofstream output(output_file);
    if (!output) {
        cerr << "Ошибка: не удалось открыть файл для записи." << endl;
        exit(EXIT_FAILURE);
    }

    output << "Время 'туда и обратно' (микросекунды):\n";
    for (const auto& time : round_trip_times) {
        output << time << "\n";
    }
    output << "\nСреднее время 'туда и обратно': " << avg_round_trip_time << " микросекунд\n";

    output << "\nВремя в одну сторону (микросекунды):\n";
    for (const auto& time : one_way_times) {
        output << time << "\n";
    }
    output << "\nСреднее время в одну сторону: " << avg_one_way_time << " микросекунд\n";
    output << "\nПропускная способность: " << throughput << " в битах/секунду\n";
    output << "Общее время передачи: " << total_time << " секунд\n";
    output << "Общий объем данных: " << num_packets * packet_size * 8 << " бит\n";
    // Освобождаем ресурсы
    delete[] buffer;
    close(client_socket);

    cout << "Клиент завершил работу. Результаты сохранены в файл: " << output_file << endl;
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        cerr << "Использование: " << argv[0] << " <режим> [опции]" << endl;
        cerr << "Режимы:\n"
             << "  server <порт> <размер_пакета> <количество_пакетов>\n"
             << "  client <IP_сервера> <порт> <размер_пакета> <количество_пакетов> <интервал_мс> <файл_результатов>" << endl;
        return EXIT_FAILURE;
    }
    string mode = argv[1];
    if (mode == "server") {
        if (argc != 5) {
            cerr << "Использование: server <порт> <размер_пакета> <количество_пакетов>" << endl;
            return EXIT_FAILURE;
        }
        int port = stoi(argv[2]);
        size_t packet_size = stoul(argv[3]);
        size_t num_packets = stoul(argv[4]);
        run_server(port, packet_size, num_packets);
    } else if (mode == "client") {
        if (argc != 8) {
            cerr << "Использование: client <IP_сервера> <порт> <размер_пакета> <количество_пакетов> <интервал_мс> <файл_результатов>" << endl;
            return EXIT_FAILURE;
        }
        string server_ip = argv[2];
        int port = stoi(argv[3]);
        size_t packet_size = stoul(argv[4]);
        size_t num_packets = stoul(argv[5]);
        int interval_ms = stoi(argv[6]);
        string output_file = argv[7];
        run_client(server_ip, port, packet_size, num_packets, interval_ms, output_file);
    } else {
        cerr << "Ошибка: неверный режим. Используйте 'server' или 'client'." << endl;
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}