refactor: move searching to static library

CMakeLists.txt

@@ -5,6 +5,8 @@ project(
   VERSION 0.1.0
   LANGUAGES CXX)
 
+add_subdirectory(lib_vector_search)
+
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
 
 include(ExportCompileCommands)
@@ -12,6 +14,8 @@ include(sccache)
 
 add_executable(VectorSearch main.cpp)
 
+target_link_libraries(VectorSearch lib_vector_search)
+
 target_compile_features(VectorSearch PUBLIC cxx_std_20)
 
 set_target_properties(

lib_vector_search/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.20)
+
+project(
+  lib_vector_search
+  VERSION 0.1.0
+  LANGUAGES CXX)
+
+add_library(
+  lib_vector_search STATIC src/word_list_generator.cpp src/timer.cpp
+                           src/linear_finder.cpp src/parallel_finder.cpp)
+
+target_include_directories(lib_vector_search
+                           PUBLIC ${PROJECT_SOURCE_DIR}/include)
+
+target_compile_features(lib_vector_search PUBLIC cxx_std_20)

lib_vector_search/include/finder.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+using std::string, std::string_view, std::vector;
+
+class Finder {
+public:
+  virtual ~Finder() = default;
+  virtual vector<const string *> find_prefix(string_view search_term) const = 0;
+};

lib_vector_search/include/linear_finder.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "finder.h"
+
+class LinearFinder : public Finder {
+private:
+  const vector<string> &word_list_;
+
+public:
+  LinearFinder(const vector<string> &word_list);
+  vector<const string *> find_prefix(string_view search_term) const override;
+};

lib_vector_search/include/parallel_finder.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "finder.h"
+
+class ParallelFinder : public Finder {
+private:
+  const size_t thread_count_;
+  const vector<string> &word_list_;
+
+public:
+  ParallelFinder(const vector<string> &word_list, size_t thread_count);
+  vector<const string *> find_prefix(string_view search_term) const override;
+};

lib_vector_search/include/timer.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <chrono>
+#include <string>
+
+class Timer {
+private:
+  std::string name_;
+  std::chrono::time_point<std::chrono::high_resolution_clock> start_;
+
+public:
+  Timer(std::string_view name);
+
+  void start();
+  void stop();
+};

lib_vector_search/include/word_list_generator.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+class WordListGenerator {
+private:
+  static const std::string charset_;
+
+public:
+  std::vector<std::string> generate();
+};

lib_vector_search/src/linear_finder.cpp

@@ -0,0 +1,17 @@
+#include "linear_finder.h"
+
+LinearFinder::LinearFinder(const vector<string> &word_list)
+    : word_list_(word_list) {}
+
+vector<const string *>
+LinearFinder::find_prefix(string_view search_term) const {
+  vector<const string *> matching_words;
+
+  for (const auto &current_word : word_list_) {
+    if (current_word.starts_with(search_term)) {
+      matching_words.push_back(&current_word);
+    }
+  }
+
+  return matching_words;
+}

lib_vector_search/src/parallel_finder.cpp

@@ -0,0 +1,47 @@
+#include "parallel_finder.h"
+
+#include <mutex>
+#include <thread>
+
+using std::mutex, std::thread, std::lock_guard;
+
+ParallelFinder::ParallelFinder(const vector<string> &word_list,
+                               size_t thread_count)
+    : word_list_(word_list), thread_count_(thread_count) {}
+
+vector<const string *>
+ParallelFinder::find_prefix(string_view search_term) const {
+  vector<const string *> result;
+  mutex result_mutex;
+
+  vector<thread> threads;
+  for (size_t thread_index = 0; thread_index < thread_count_; ++thread_index) {
+    const size_t first_word_index =
+        thread_index * (word_list_.size() / thread_count_);
+    const size_t last_word_index =
+        (thread_index == thread_count_ - 1)
+            ? word_list_.size()
+            : (thread_index + 1) * (word_list_.size() / thread_count_);
+
+    threads.emplace_back(
+        [](const vector<string> &word_list, const string_view &search_term,
+           vector<const string *> &result, size_t start_index, size_t end_index,
+           mutex &result_mutex) {
+          for (size_t index = start_index; index < end_index; ++index) {
+            const auto &current_word = word_list[index];
+            if (current_word.starts_with(search_term)) {
+              const lock_guard<mutex> lock(result_mutex);
+              result.push_back(&current_word);
+            }
+          }
+        },
+        cref(word_list_), cref(search_term), ref(result), first_word_index,
+        last_word_index, ref(result_mutex));
+  }
+
+  for (auto &thread : threads) {
+    thread.join();
+  }
+
+  return result;
+}

lib_vector_search/src/timer.cpp

@@ -0,0 +1,17 @@
+#include "timer.h"
+
+#include <chrono>
+#include <iostream>
+
+Timer::Timer(std::string_view name) : name_(name) { start(); };
+
+void Timer::start() { start_ = std::chrono::high_resolution_clock::now(); }
+
+void Timer::stop() {
+  auto end = std::chrono::high_resolution_clock::now();
+
+  auto duration =
+      std::chrono::duration_cast<std::chrono::microseconds>(end - start_);
+
+  std::cout << name_ << " took " << duration << std::endl;
+}

lib_vector_search/src/word_list_generator.cpp

@@ -0,0 +1,34 @@
+#include "word_list_generator.h"
+
+#include <algorithm>
+#include <cmath>
+#include <random>
+
+const std::string WordListGenerator::charset_ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+std::vector<std::string> WordListGenerator::generate() {
+  const size_t multiplier = 10;
+
+  std::vector<std::string> result;
+  result.reserve(multiplier * std::pow(charset_.length(), 4));
+
+  for (auto char_1 : charset_) {
+    for (auto char_2 : charset_) {
+      for (auto char_3 : charset_) {
+        for (auto char_4 : charset_) {
+          for (auto i = 0; i < multiplier; ++i) {
+            result.emplace_back(
+                std::initializer_list<char>({char_1, char_2, char_3, char_4}));
+          }
+        }
+      }
+    }
+  }
+
+  std::random_device random_device;
+  std::mt19937 random_number_generator(random_device());
+
+  std::shuffle(result.begin(), result.end(), random_number_generator);
+
+  return result;
+}

main.cpp

@@ -1,7 +1,66 @@
+#include "linear_finder.h"
+#include "parallel_finder.h"
+#include "timer.h"
+#include "word_list_generator.h"
+
+#include <cstdlib>
 #include <iostream>
+#include <thread>
+
+using std::string, std::string_view, std::vector, std::thread, std::cout,
+    std::endl;
+
+vector<string> generate_word_list() {
+  cout << "\ngenerating word list" << endl;
+
+  Timer generator_timer("word list generator");
+  auto word_list = WordListGenerator().generate();
+  generator_timer.stop();
+
+  cout << "word list is " << word_list.size() << " element(s) long" << endl;
+
+  return word_list;
+}
+
+void test_linear_finder(const vector<string> &word_list) {
+  cout << "\nrunning linear finder" << endl;
+
+  Timer constructor_timer("linear finder constructor");
+  LinearFinder linear_finder(word_list);
+  constructor_timer.stop();
+
+  Timer find_timer("linear finder find");
+  auto result = linear_finder.find_prefix("ABCD");
+  find_timer.stop();
+
+  cout << "result list is " << result.size() << " element(s) long" << endl;
+}
+
+void test_parallel_finder(const vector<string> &word_list) {
+  cout << "\nrunning parallel finder" << endl;
+
+  const size_t thread_count = thread::hardware_concurrency();
+
+  cout << "using " << thread_count << " threads" << endl;
+
+  Timer constructor_timer("parallel finder constructor");
+  ParallelFinder parallel_finder(word_list, thread_count);
+  constructor_timer.stop();
+
+  Timer find_timer("parallel finder find");
+  auto result = parallel_finder.find_prefix("ABCD");
+  find_timer.stop();
+
+  cout << "result list is " << result.size() << " element(s) long" << endl;
+}
 
 int main(int argc, char *argv[]) {
-  std::cout << "VectorSearch" << std::endl;
+  cout << "\n== VectorSearch ==" << endl;
 
-  return 0;
+  auto word_list = generate_word_list();
+
+  test_linear_finder(word_list);
+  test_parallel_finder(word_list);
+
+  return EXIT_SUCCESS;
 }