wip

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "third_party/rapidjson"]
 	path = third_party/rapidjson
 	url = https://github.com/miloyip/rapidjson
+[submodule "third_party/tiny-process-library"]
+	path = third_party/tiny-process-library
+	url = https://github.com/eidheim/tiny-process-library/

indexer.cpp

@@ -913,7 +913,7 @@ void WriteToFile(const std::string& filename, const std::string& content) {
   file << content;
 }
 
-int main(int argc, char** argv) {
+int main3(int argc, char** argv) {
   // TODO: Assert that we need to be on clang >= 3.9.1
 
   /*

query.cc

@@ -1,3 +1,5 @@
+#include "query.h"
+
 #include <cstdint>
 #include <unordered_map>
 #include <string>
@@ -54,37 +56,6 @@ struct QueryableDatabase {
 
 
 
-
-// Task running in a separate process, parsing a file into something we can
-// import.
-struct ParseTask {};
-// Completed parse task that wants to import content into the global database.
-// Runs in main process, primary thread. Stops all other threads.
-struct IndexImportTask {};
-// Completed parse task that wants to update content previously imported into
-// the global database. Runs in main process, primary thread. Stops all other
-// threads.
-//
-// Note that this task just contains a set of operations to apply to the global
-// database. The operations come from a diff based on the previously indexed
-// state in comparison to the newly indexed state.
-//
-// TODO: We may be able to run multiple freshen and import tasks in parallel if
-//       we restrict what ranges of the db they may change.
-struct IndexFreshenTask {};
-// Task running a query against the global database. Run in main process,
-// separate thread.
-struct QueryTask {};
-
-
-// NOTE: When something enters a value into master db, it will have to have a
-//       ref count, since multiple parsings could enter it (unless we require
-//       that it be defined in that declaration unit!)
-struct TaskManager {
-
-};
-
-
 struct Query {
 
 };
@@ -109,12 +80,6 @@ struct DocumentDiff {
 
 
 
-// NOTE: If updating this enum, make sure to also update the parser and the
-//       help text.
-enum class PreferredSymbolLocation {
-  Declaration,
-  Definition
-};
 
 bool ParsePreferredSymbolLocation(const std::string& content, PreferredSymbolLocation* obj) {
 #define PARSE_AS(name, string)      \
@@ -130,19 +95,6 @@ bool ParsePreferredSymbolLocation(const std::string& content, PreferredSymbolLoc
 #undef PARSE_AS
 }
 
-// NOTE: If updating this enum, make sure to also update the parser and the
-//       help text.
-enum class Command {
-  Callees,
-  Callers,
-  FindAllUsages,
-  FindInterestingUsages,
-  GotoReferenced,
-  Hierarchy,
-  Outline,
-  Search
-};
-
 bool ParseCommand(const std::string& content, Command* obj) {
 #define PARSE_AS(name, string)      \
   if (content == #string) {         \

query.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// NOTE: If updating this enum, make sure to also update the parser and the
+//       help text.
+enum class Command {
+  Callees,
+  Callers,
+  FindAllUsages,
+  FindInterestingUsages,
+  GotoReferenced,
+  Hierarchy,
+  Outline,
+  Search
+};
+
+// NOTE: If updating this enum, make sure to also update the parser and the
+//       help text.
+enum class PreferredSymbolLocation {
+  Declaration,
+  Definition
+};

task.cc

@@ -0,0 +1,111 @@
+#include <condition_variable>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+#include "indexer.h"
+#include "query.h"
+
+#include "third_party/tiny-process-library/process.hpp"
+
+struct BaseTask {
+  int priority = 0;
+  bool writes_to_index = false;
+};
+
+// Task running in a separate process, parsing a file into something we can
+// import.
+struct IndexCreateTask : public BaseTask {
+  IndexCreateTask() {
+    writes_to_index = true;
+  }
+};
+
+// Completed parse task that wants to import content into the global database.
+// Runs in main process, primary thread. Stops all other threads.
+struct IndexImportTask : public BaseTask {
+  IndexImportTask() {
+    writes_to_index = true;
+  }
+};
+
+// Completed parse task that wants to update content previously imported into
+// the global database. Runs in main process, primary thread. Stops all other
+// threads.
+//
+// Note that this task just contains a set of operations to apply to the global
+// database. The operations come from a diff based on the previously indexed
+// state in comparison to the newly indexed state.
+//
+// TODO: We may be able to run multiple freshen and import tasks in parallel if
+//       we restrict what ranges of the db they may change.
+struct IndexFreshenTask : public BaseTask {
+  IndexFreshenTask() {
+    writes_to_index = true;
+  }
+};
+
+// Task running a query against the global database. Run in main process,
+// separate thread.
+struct QueryTask : public BaseTask {
+  QueryTask() {
+    writes_to_index = false;
+  }
+
+  Command query;
+  Location location;
+  std::string argument;
+};
+
+
+// NOTE: When something enters a value into master db, it will have to have a
+//       ref count, since multiple parsings could enter it (unless we require
+//       that it be defined in that declaration unit!)
+struct TaskManager {
+  // Tasks that are currently executing.
+  std::vector<BaseTask> running;
+  std::vector<BaseTask> pending;
+
+  // Available threads.
+  std::vector<std::thread> threads;
+  std::condition_variable wakeup_thread;
+  std::mutex mutex;
+
+  TaskManager(int num_threads);
+};
+
+static void ThreadMain(int id, std::condition_variable* waiter, std::mutex* mutex) {
+  std::unique_lock<std::mutex> lock(*mutex);
+  waiter->wait(lock);
+
+  std::cout << id << ": running in thread main" << std::endl;
+}
+
+TaskManager::TaskManager(int num_threads) {
+  for (int i = 0; i < num_threads; ++i) {
+    threads.push_back(std::thread(&ThreadMain, i, &wakeup_thread, &mutex));
+  }
+}
+
+void Pump(TaskManager* tm) {
+  //tm->threads[0].
+}
+
+int main(int argc, char** argv) {
+  TaskManager tm(10);
+
+  // TODO: looks like we will have to write shared memory support.
+
+  // TODO: We signal thread to pick data, thread signals data pick is done.
+  //       Repeat until we encounter a writer, wait for all threads to signal
+  //       they are done.
+  // TODO: Let's use a thread safe queue/vector/etc instead.
+  tm.wakeup_thread.notify_one();
+  tm.wakeup_thread.notify_one();
+
+  for (std::thread& thread : tm.threads)
+    thread.join();
+
+  std::cin.get();
+  return 0;
+}

third_party/tiny-process-library

@@ -0,0 +1 @@
+Subproject commit 876ce117e7c92458bd1322f39935f28419d87b20