Create lazy version of challenges input generation.

Changes sample job script files.
Fixed sum challenge template.

Author: oraqlle

challenges/distributed-computing/hello/README.md

@@ -4,4 +4,6 @@
 
 ```sh
 "Hello, world! from processor <name>, rank <ID> out of <total> processors
+
+# Repeated for however many nodes you allocated.
 ```

challenges/distributed-computing/job.slurm

@@ -2,6 +2,7 @@
 
 #SBATCH --job-name=
 #SBATCH --time=0:05:00
+#SBATCH --mem=1GB
 #SBATCH --ntasks=1
 #SBATCH --ntasks-per-node=1
 #SBATCH --cpus-per-task=1

challenges/distributed-computing/sum/sum.c

@@ -13,7 +13,7 @@ int main(int argc, char* argv[])
     unsigned N = atoi(argv[1]);
     double* input = (double*)malloc(N * sizeof(double));
 
-    MPI_INIT(&argc, &argv[0]);
+    MPI_Init(&argc, &argv);
 
     MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
     MPI_Comm_size(MPI_COMM_WORLD, &world_size);

challenges/parallel-computing/job.slurm

@@ -2,7 +2,9 @@
 
 #SBATCH --job-name=
 #SBATCH --time=0:05:00
+#SBATCH --mem=1GB
 #SBATCH --ntasks=1
+#SBATCH --ntasks-per-node=1
 #SBATCH --cpus-per-task=1
 #SBATCH --partition=
 #SBATCH --output=slurm-%x.out

generate-lazy.cpp

@@ -0,0 +1,107 @@
+// Copyright (c) Tyler Swann 2023
+// Made in partnership with Monash DeepNeuron
+// for Monash DeepNeuron's HPC Training.
+
+// Details
+// This program will generate the input files
+// containing the random list of numbers used
+// by in some of the challenges.
+//
+// Build
+// $ g++ -std=c++20 -o bin/generate generate.cpp
+//
+// Run
+// $ bin/generate
+
+#include <algorithm>
+#include <concepts>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <random>
+#include <ranges>
+#include <string_view>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+constexpr std::size_t default_problem_size = 1'000'000uL;
+
+fs::path main_path = fs::current_path() / "challenges" / "distributed-computing";
+fs::path sum_path = main_path / "sum";
+fs::path mergesort_path = main_path / "mergesort";
+
+auto gen = std::mt19937 { std::random_device {}() };
+auto distrib = std::uniform_real_distribution { -1.0e5, 1.0e5 };
+auto generate = std::views::transform([]([[maybe_unused]] auto x) -> double { return distrib(gen); });
+
+template <std::ranges::range Range>
+auto write(const fs::path& filename, Range&& data) -> void
+{
+    auto file = std::fstream { filename, std::ios::in | std::ios::out | std::ios::trunc };
+
+    if (file.is_open()) {
+        std::ranges::copy(data, std::ostream_iterator<double>(file, "\n"));
+    } else
+        std::clog << "Failed to open file" << filename << std::endl;
+}
+
+auto write(const fs::path& filename, const double& data) -> void
+{
+    auto file = std::fstream { filename, std::ios::in | std::ios::out | std::ios::trunc };
+
+    if (file.is_open()) {
+        file << data << std::endl;
+    } else
+        std::clog << "Failed to open file" << filename << std::endl;
+}
+
+namespace make {
+
+auto sum(std::size_t problem_size) -> void
+{
+    auto nums = std::views::iota(0)
+        | generate
+        | std::views::take(problem_size)
+        | std::views::common;
+
+    auto sum = std::accumulate(nums.begin(), nums.end(), double {});
+
+    write(sum_path / "input.txt", nums);
+    write(sum_path / "output.txt", sum);
+}
+
+// auto mergesort(std::size_t problem_size) -> void
+// {
+//     auto nums = std::views::iota(0) | generate | std::views::take(problem_size);
+//     write(mergesort_path / "unsorted.txt", nums);
+
+//     std::ranges::sort(nums);
+
+//     if (!std::ranges::is_sorted(nums)) {
+//         std::clog << "Didn't sort input" << std::endl;
+//         return;
+//     }
+
+//     write(mergesort_path / "sorted.txt", nums);
+// }
+
+} // namespace make
+
+int main(int argc, char* argv[])
+{
+    std::size_t problem_size = default_problem_size;
+
+    if (argc > 1) {
+        problem_size = std::atoll(argv[1]);
+        problem_size = std::ranges::clamp(problem_size, default_problem_size, std::vector<double> {}.max_size());
+    }
+
+    // auto buffer = std::vector<double>(problem_size, 0.0);
+
+    make::sum(problem_size);
+    // make::mergesort(problem_size);
+
+    return 0;
+}