demo.cpp

#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>
#include <algorithm>
#include <numeric>
#include <cmath>

using namespace std;

struct Task {
    int id;
    vector<double> data;
};

struct Result {
    int task_id, worker_id;
    double mean, variance, std_dev, min_val, max_val, execution_time;
};

class Worker {
public:
    int id, tasks_completed;
    double total_time;
    
    Worker(int w) : id(w), tasks_completed(0), total_time(0.0) {}
    
    Result executeTask(const Task& task) {
        clock_t start = clock();
        Result r;
        r.task_id = task.id;
        r.worker_id = id;
        
        double sum = 0.0;
        for (size_t i = 0; i < task.data.size(); i++) sum += task.data[i];
        r.mean = sum / task.data.size();
        
        double sq_sum = 0.0;
        for (size_t i = 0; i < task.data.size(); i++) sq_sum += task.data[i] * task.data[i];
        r.variance = sq_sum / task.data.size() - r.mean * r.mean;
        r.std_dev = sqrt(r.variance);
        
        r.min_val = *min_element(task.data.begin(), task.data.end());
        r.max_val = *max_element(task.data.begin(), task.data.end());
        
        r.execution_time = double(clock() - start) / CLOCKS_PER_SEC;
        tasks_completed++;
        total_time += r.execution_time;
        return r;
    }
};

class LoadBalancer {
    int num_workers, current_worker;
public:
    LoadBalancer(int w) : num_workers(w), current_worker(0) {}
    int assignTask() {
        int a = current_worker;
        current_worker = (current_worker + 1) % num_workers;
        return a;
    }
};

int main() {
    cout << "==========================================\n";
    cout << " Distributed Computing Framework Demo\n";
    cout << " Aug 2022 - Nov 2022 Project\n";
    cout << "==========================================\n\n";
    
    const int NUM_WORKERS = 4, NUM_TASKS = 20;
    
    cout << "Config: " << NUM_WORKERS << " workers, " << NUM_TASKS << " tasks\n\n";
    
    vector<Worker> workers;
    for (int i = 0; i < NUM_WORKERS; i++) workers.push_back(Worker(i));
    
    LoadBalancer balancer(NUM_WORKERS);
    
    cout << "Creating tasks...\n";
    srand((unsigned)time(0));
    vector<Task> tasks;
    for (int i = 0; i < NUM_TASKS; i++) {
        Task t;
        t.id = i;
        for (int j = 0; j < 1000; j++) t.data.push_back((double)rand() / RAND_MAX * 100.0);
        tasks.push_back(t);
    }
    
    cout << "Distributing tasks...\n\n";
    clock_t start = clock();
    vector<Result> results;
    
    for (int i = 0; i < NUM_TASKS; i++) {
        int w = balancer.assignTask();
        cout << "Task " << i << " -> Worker " << w << "... ";
        Result r = workers[w].executeTask(tasks[i]);
        results.push_back(r);
        cout << "done\n";
    }
    
    double total = double(clock() - start) / CLOCKS_PER_SEC;
    
    cout << "\n==========================================\n";
    cout << " Execution Complete!\n";
    cout << "==========================================\n\n";
    cout << "Total Time: " << total << "s\n";
    cout << "Tasks: " << results.size() << "/" << NUM_TASKS << "\n\n";
    
    cout << "Worker Performance:\n";
    for (int i = 0; i < NUM_WORKERS; i++) {
        printf("  Worker %d: %d tasks, %.4fs total\n", 
               i, workers[i].tasks_completed, workers[i].total_time);
    }
    
    cout << "\nSample Result (Task 0):\n";
    printf("  Mean: %.2f, StdDev: %.2f\n", results[0].mean, results[0].std_dev);
    printf("  Min: %.2f, Max: %.2f\n", results[0].min_val, results[0].max_val);
    
    cout << "\nFeatures: Load Balancing, Data Partitioning, Monitoring\n";
    return 0;
}