sequential.cpp

#include <fstream>
#include <unordered_map>
#include <string>
#include <cctype>
#include <iostream>
#include <vector>
#include <algorithm>
#include <omp.h>

using namespace std;

void process_word(string &w) {
    // Remove punctuation and non-ascii chars at beginning
    while (!w.empty()) {
        signed char c = w.front();
        if (c < 0 || ispunct(c)) {
            w.erase(0, 1);
            continue;
        }
        break;
    }
    // Remove punctuation and non-ascii chars at end
    while (!w.empty()) {
        signed char c = w.back();
        if (c < 0 || ispunct(c)) {
            w.pop_back();
            continue;
        }
        break;
    }
    // Convert all letters to lowercase
    for (char &ch : w) {
        unsigned char c = static_cast<unsigned char>(ch);
        if (isupper(c)) {
            ch = tolower(c);
        }
    }
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        fprintf(stderr, "usage: %s <input_files>\n", argv[0]);
        return 1;
    }

    vector<pair<string, size_t>> raw_tuples;
    size_t file_word_count = 0;

    double start, end;
    start = omp_get_wtime();

    // File reading step
    size_t f_count = 1;
    while (argv[f_count]) {
        ifstream fin(argv[f_count]);
        if (!fin) {
            fprintf(stderr, "error: unable to open input file: %s\n", argv[f_count]);
            return 1;
        }

        string word;
        while (fin >> word) {
            process_word(word);
            // Map step
            if (!word.empty()) {          // avoid pushing empty strings
                file_word_count++;
                raw_tuples.push_back({word, 1});
            }
        }
        f_count++;
    }

    // Shuffle step
    unordered_map<string, vector<size_t>> buckets;
    for (size_t i = 0; i < raw_tuples.size(); ++i) {
        buckets[raw_tuples[i].first].push_back(raw_tuples[i].second);
    }
    double start_r = omp_get_wtime();
    // Reduce step
    vector<pair<string, size_t>> counts;
    for (auto entry : buckets) {
        size_t sum = 0;
        for (size_t i = 0; i < entry.second.size(); ++i) {
            sum += entry.second[i];
        }
        counts.push_back({entry.first, sum});
    }
    double start_p = omp_get_wtime();
    // Sort in alphabetical order
    sort(counts.begin(), counts.end(), [](const pair<string, int> &a, const pair<string, int> &b) {
        return a.first < b.first;
    });

    // Writing step
    ofstream fout("results_seq.txt");
    fout << "Filename: " << argv[1] << ", total words: " << file_word_count << '\n';
    for (size_t i = 0; i < counts.size(); ++i) {
        fout << "[" << i << "] " << counts[i].first << ": " << counts[i].second << '\n';
    }

    end = omp_get_wtime();
    // Use cerr to always print in terminal
    cerr << "Sequential time: " << (end - start) * 1000 << " ms\n";
    cerr << "\tFile Read & Map time: " << (start_r - start) * 1000 << " ms\n"; 
    cerr << "\tReduce time: " << (start_p - start_r) * 1000 << "ms\n";
    cerr << "\tSort & print time: " << (end - start_p) * 1000 << "ms\n";
    return 0;
}