start moving algorithm in

userland/algorithm/set/main.hpp

@@ -18,9 +18,10 @@
 #include <lkmc/m5ops.h>
 
 int main(int argc, char **argv) {
+    // Variables.
     typedef uint64_t T;
 #if LKMC_ALGORITHM_SET_STD_PRIORITY_QUEUE
-    std::priority_queue<T> set;
+    std::priority_queue<T, std::vector<T>, std::greater<T>> set;
 #endif
 #if LKMC_ALGORITHM_SET_STD_SET
     std::set<T> set;
@@ -28,57 +29,59 @@ int main(int argc, char **argv) {
 #if LKMC_ALGORITHM_SET_STD_UNORDERED_SET
     std::unordered_set<T> set;
 #endif
-    std::vector<T> randoms;
+    std::vector<T> input;
     size_t i, j = 0, n, granule, base;
-    unsigned int seed;
 #ifndef LKMC_M5OPS_ENABLE
     std::vector<std::chrono::nanoseconds::rep> dts;
     std::vector<decltype(base)> bases;
+    using clk = std::chrono::high_resolution_clock;
+    decltype(clk::now()) start, end;
 #endif
 
     // CLI arguments.
+    //
+    // Save the clock time every `granule` loops.
+    //
+    // The magic value 0 means that a single time for the entire
+    // run is printed, therefore accounting for the full run time.
+    //
+    // Otherwise, must be a divisor of the input size.
+    //
+    // Default value: 0
     if (argc > 1) {
-        n = std::stoi(argv[1]);
+        granule = std::stoll(argv[1]);
     } else {
-        n = 10;
+        granule = 0;
     }
-    if (argc > 2) {
-        granule = std::stoi(argv[2]);
-    } else {
-        granule = 1;
+
+    // Read input from stdin.
+    std::string str;
+    while (std::getline(std::cin, str)) {
+        if (str == "")
+            break;
+        input.push_back(std::stoll(str));
     }
-    if (argc > 3) {
-        seed = std::stoi(argv[3]);
-    } else {
-        seed = std::random_device()();
+    n = input.size();
+    if (granule == 0) {
+        granule = n;
     }
 
     // Action.
-    for (i = 0; i < n; ++i) {
-        randoms.push_back(i);
-    }
-    std::shuffle(randoms.begin(), randoms.end(), std::mt19937(seed));
     for (i = 0; i < n / granule; ++i) {
-#ifndef LKMC_M5OPS_ENABLE
-        using clk = std::chrono::high_resolution_clock;
-        decltype(clk::now()) start, end;
-#endif
         base = i * granule;
-#ifdef LKMC_M5OPS_ENABLE
-        LKMC_M5OPS_RESETSTATS;
-#else
+#ifndef LKMC_M5OPS_ENABLE
         start = clk::now();
+#endif
         for (j = 0; j < granule; ++j) {
-#endif
+            LKMC_M5OPS_RESETSTATS;
 #if LKMC_ALGORITHM_SET_STD_PRIORITY_QUEUE
-        set.emplace(randoms[base + j]);
+            set.emplace(input[base + j]);
 #else
-        set.insert(randoms[base + j]);
+            set.insert(input[base + j]);
 #endif
-#ifdef LKMC_M5OPS_ENABLE
-        LKMC_M5OPS_DUMPSTATS;
-#else
+            LKMC_M5OPS_DUMPSTATS;
         }
+#ifndef LKMC_M5OPS_ENABLE
         end = clk::now();
         auto dt = (end - start) / granule;
         bases.push_back(base);
@@ -87,8 +90,26 @@ int main(int argc, char **argv) {
     }
 
     // Report results.
+    std::cout << "output" << std::endl;
+#if LKMC_ALGORITHM_SET_STD_PRIORITY_QUEUE
+    // Print priority queue without duplicates.
+    T last_val = set.top();
+    std::cout << last_val << std::endl;
+    set.pop();
+    while (!set.empty()) {
+        const auto& val = set.top();
+        if (val != last_val)
+            std::cout << val << std::endl;
+        last_val = val;
+        set.pop();
+    }
+#else
+    for (const auto& item : set) {
+        std::cout << item << std::endl;
+    }
+#endif
+    std::cout << std::endl;
 #ifndef LKMC_M5OPS_ENABLE
-    // Output.
     std::cout << "times" << std::endl;
     auto bases_it = bases.begin();
     auto dts_it = dts.begin();
@@ -99,17 +120,5 @@ int main(int argc, char **argv) {
         bases_it++;
         dts_it++;
     }
-    std::cout << std::endl;
-    std::cout << "output" << std::endl;
-#if LKMC_ALGORITHM_SET_STD_PRIORITY_QUEUE
-    while (!set.empty()) {
-        std::cout << set.top() << std::endl;
-        set.pop();
-    }
-#else
-    for (const auto& item : set) {
-        std::cout << item << std::endl;
-    }
-#endif
 #endif
 }