Add parallel-letter-frequency (#800)

Co-authored-by: Matthias <[email protected]>
Co-authored-by: Christian Willner <[email protected]>

Author: 3 people

config.json

@@ -1169,6 +1169,14 @@
         "prerequisites": [],
         "difficulty": 5
       },
+      {
+        "slug": "parallel-letter-frequency",
+        "name": "Parallel Letter Frequency",
+        "uuid": "0a029212-bc55-4559-b3c6-2c26bec0d560",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 6
+      },
       {
         "slug": "pig-latin",
         "name": "Pig Latin",

exercises/practice/parallel-letter-frequency/.docs/instructions.append.md

@@ -0,0 +1,49 @@
+# Instructions append
+ 
+## Additional Notes for C++ Implementation
+
+There are several ways how to achieve parallelism in C++.
+Exercism's online runner supports C++17, so you can use execution policies from the [algorithms library][algorithm].
+Another option is manually managing [threads][thread].
+However, note that spawning a thread is quite expensive (using a thread [pool][pool] would help).
+
+When working locally, you can of course use whatever you want.
+However, a solution using non-standard libraries will most probably not work with the Exercism online runner.
+
+### Benchmark
+
+When working locally, you can optionally run a benchmark to get an idea about the speedup of different implementations.
+Activating the CMake flag `EXERCISM_INCLUDE_BENCHMARK` enables the benchmark:
+```
+cmake -DEXERCISM_RUN_ALL_TESTS=1 -DEXERCISM_INCLUDE_BENCHMARK=1 .
+```
+
+### Compiler support for parallel algorithms
+
+GCC's implementation of the C++ standard library (`libstdc++`) relies on [TBB][tbb].
+If TBB is not available, a fall back to a sequential version will be used, even when parallel execution is requested.
+
+On Ubuntu, you need to install the `libtbb-dev` package:
+```
+apt-get install libtbb-dev
+```
+
+On macOS, you can use [Homebrew][homebrew] to install TBB:
+```
+brew install tbb
+```
+
+Clang `libc++` as of version 17 has experimental, partial support for parallel algorithms.
+To switch it on, the `-fexperimental-library` compiler flags needs to be given.
+
+Apple Clang 15 and earlier _do not_ support parallel algorithms.
+
+On Linux and macOS we recommend using GCC (along with the default `libstdc++`) for this exercise.
+
+Microsoft's MSVC supports parallel algorithms at least since VS 2017 15.7 without having to install any additional library.
+
+[algorithm]: https://en.cppreference.com/w/cpp/algorithm
+[thread]: https://en.cppreference.com/w/cpp/thread/thread
+[pool]: https://en.wikipedia.org/wiki/Thread_pool
+[tbb]: https://en.wikipedia.org/wiki/Threading_Building_Blocks
+[homebrew]: https://brew.sh/

exercises/practice/parallel-letter-frequency/.docs/instructions.md

@@ -0,0 +1,7 @@
+# Instructions
+
+Count the frequency of letters in texts using parallel computation.
+
+Parallelism is about doing things in parallel that can also be done sequentially.
+A common example is counting the frequency of letters.
+Create a function that returns the total frequency of each letter in a list of texts and that employs parallelism.

exercises/practice/parallel-letter-frequency/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "ahans"
+  ],
+  "files": {
+    "solution": [
+      "parallel_letter_frequency.cpp",
+      "parallel_letter_frequency.h"
+    ],
+    "test": [
+      "parallel_letter_frequency_test.cpp"
+    ],
+    "example": [
+      ".meta/example.cpp",
+      ".meta/example.h"
+    ]
+  },
+  "blurb": "Count the frequency of letters in texts using parallel computation."
+}

exercises/practice/parallel-letter-frequency/.meta/example.cpp

@@ -0,0 +1,45 @@
+#include "parallel_letter_frequency.h"
+
+#include <algorithm>
+#include <cctype>
+
+// Apple Clang does not support C++17 parallel algorithms.
+#ifdef __apple_build_version__
+#define PAR_UNSEQ
+#else
+#include <execution>
+#define PAR_UNSEQ std::execution::par_unseq,
+#endif
+
+namespace parallel_letter_frequency {
+
+namespace {
+
+[[nodiscard]] std::unordered_map<char, size_t> frequency(
+    std::string_view const text) {
+    std::unordered_map<char, size_t> freq;
+    for (unsigned char c : text) freq[std::tolower(c)] += 1;
+    return freq;
+}
+
+}  // namespace
+
+std::unordered_map<char, size_t> frequency(
+    std::vector<std::string_view> const& texts) {
+    std::vector<std::unordered_map<char, size_t>> freqs(texts.size());
+    // determine frequencies of texts in parallel
+    std::transform(PAR_UNSEQ texts.cbegin(), texts.cend(), freqs.begin(),
+                   [](auto text) { return frequency(text); });
+
+    // combine individual frequencies (this happens sequentially)
+    std::unordered_map<char, size_t> totals{};
+    for (auto const& single_text_freqs : freqs) {
+        for (auto const [c, count] : single_text_freqs) {
+            totals[c] += count;
+        }
+    }
+
+    return totals;
+}
+
+}  // namespace parallel_letter_frequency

exercises/practice/parallel-letter-frequency/.meta/example.h

@@ -0,0 +1,15 @@
+#if !defined(PARALLEL_LETTER_FREQUENCY_H)
+#define PARALLEL_LETTER_FREQUENCY_H
+
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace parallel_letter_frequency {
+
+[[nodiscard]] std::unordered_map<char, size_t> frequency(
+    std::vector<std::string_view> const& texts);
+
+}
+
+#endif

exercises/practice/parallel-letter-frequency/.meta/tests.toml

@@ -0,0 +1,50 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[c054d642-c1fa-4234-8007-9339f2337886]
+description = "no texts"
+
+[818031be-49dc-4675-b2f9-c4047f638a2a]
+description = "one text with one letter"
+
+[c0b81d1b-940d-4cea-9f49-8445c69c17ae]
+description = "one text with multiple letters"
+
+[708ff1e0-f14a-43fd-adb5-e76750dcf108]
+description = "two texts with one letter"
+
+[1b5c28bb-4619-4c9d-8db9-a4bb9c3bdca0]
+description = "two texts with multiple letters"
+
+[6366e2b8-b84c-4334-a047-03a00a656d63]
+description = "ignore letter casing"
+
+[92ebcbb0-9181-4421-a784-f6f5aa79f75b]
+description = "ignore whitespace"
+
+[bc5f4203-00ce-4acc-a5fa-f7b865376fd9]
+description = "ignore punctuation"
+
+[68032b8b-346b-4389-a380-e397618f6831]
+description = "ignore numbers"
+
+[aa9f97ac-3961-4af1-88e7-6efed1bfddfd]
+description = "Unicode letters"
+include = false
+
+[7b1da046-701b-41fc-813e-dcfb5ee51813]
+description = "combination of lower- and uppercase letters, punctuation and white space"
+
+[4727f020-df62-4dcf-99b2-a6e58319cb4f]
+description = "large texts"
+
+[adf8e57b-8e54-4483-b6b8-8b32c115884c]
+description = "many small texts"

exercises/practice/parallel-letter-frequency/CMakeLists.txt

@@ -0,0 +1,72 @@
+# Get the exercise name from the current directory
+get_filename_component(exercise ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+
+# Basic CMake project
+cmake_minimum_required(VERSION 3.5.1)
+
+# Name the project after the exercise
+project(${exercise} CXX)
+
+# Get a source filename from the exercise name by replacing -'s with _'s
+string(REPLACE "-" "_" file ${exercise})
+
+# Implementation could be only a header
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file}.cpp)
+    set(exercise_cpp ${file}.cpp)
+else()
+    set(exercise_cpp "")
+endif()
+
+# Use the common Catch library?
+if(EXERCISM_COMMON_CATCH)
+    # For Exercism track development only
+    add_executable(${exercise} ${file}_test.cpp ${exercise_cpp} ${file}.h $<TARGET_OBJECTS:catchlib>)
+elseif(EXERCISM_TEST_SUITE)
+    # The Exercism test suite is being run, the Docker image already
+    # includes a pre-built version of Catch.
+    find_package(Catch2 REQUIRED)
+    add_executable(${exercise} ${file}_test.cpp ${exercise_cpp} ${file}.h)
+    target_link_libraries(${exercise} PRIVATE Catch2::Catch2WithMain)
+    # When Catch is installed system wide we need to include a different
+    # header, we need this define to use the correct one.
+    target_compile_definitions(${exercise} PRIVATE EXERCISM_TEST_SUITE)
+else()
+    # Build executable from sources and headers
+    add_executable(${exercise} ${file}_test.cpp ${exercise_cpp} ${file}.h test/tests-main.cpp)
+endif()
+
+set_target_properties(${exercise} PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED OFF
+    CXX_EXTENSIONS OFF
+)
+
+set(CMAKE_BUILD_TYPE Release)
+
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(GNU|Clang)")
+    find_package(TBB)
+    if (${TBB_FOUND})
+        target_link_libraries(${exercise} PRIVATE TBB::tbb)
+    endif()
+    set_target_properties(${exercise} PROPERTIES
+        COMPILE_FLAGS "-Wall -Wextra -Wpedantic -Werror"
+    )
+endif()
+
+if(${EXERCISM_INCLUDE_BENCHMARK})
+    target_compile_definitions(${exercise} PRIVATE EXERCISM_INCLUDE_BENCHMARK CATCH_CONFIG_ENABLE_BENCHMARKING)
+endif()
+
+# Configure to run all the tests?
+if(${EXERCISM_RUN_ALL_TESTS})
+    target_compile_definitions(${exercise} PRIVATE EXERCISM_RUN_ALL_TESTS)
+endif()
+
+# Tell MSVC not to warn us about unchecked iterators in debug builds
+if(${MSVC})
+    set_target_properties(${exercise} PROPERTIES
+        COMPILE_DEFINITIONS_DEBUG _SCL_SECURE_NO_WARNINGS)
+endif()
+
+# Run the tests on every build
+add_custom_target(test_${exercise} ALL DEPENDS ${exercise} COMMAND ${exercise})

exercises/practice/parallel-letter-frequency/parallel_letter_frequency.cpp

@@ -0,0 +1,2 @@
+#include "parallel_letter_frequency.h"
+

exercises/practice/parallel-letter-frequency/parallel_letter_frequency.h

@@ -0,0 +1,9 @@
+#if !defined(PARALLEL_LETTER_FREQUENCY_H)
+#define PARALLEL_LETTER_FREQUENCY_H
+
+namespace parallel_letter_frequency {
+
+}
+
+#endif
+