This commit is contained in:
Jacob Dufault 2017-02-23 01:23:23 -08:00
parent 264b687e43
commit 5faf9d1f6b
6 changed files with 139 additions and 51 deletions

3
.gitmodules vendored
View File

@ -1,3 +1,6 @@
[submodule "third_party/rapidjson"] [submodule "third_party/rapidjson"]
path = third_party/rapidjson path = third_party/rapidjson
url = https://github.com/miloyip/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/

View File

@ -913,7 +913,7 @@ void WriteToFile(const std::string& filename, const std::string& content) {
file << 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 // TODO: Assert that we need to be on clang >= 3.9.1
/* /*

View File

@ -1,3 +1,5 @@
#include "query.h"
#include <cstdint> #include <cstdint>
#include <unordered_map> #include <unordered_map>
#include <string> #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 { 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) { bool ParsePreferredSymbolLocation(const std::string& content, PreferredSymbolLocation* obj) {
#define PARSE_AS(name, string) \ #define PARSE_AS(name, string) \
@ -130,19 +95,6 @@ bool ParsePreferredSymbolLocation(const std::string& content, PreferredSymbolLoc
#undef PARSE_AS #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) { bool ParseCommand(const std::string& content, Command* obj) {
#define PARSE_AS(name, string) \ #define PARSE_AS(name, string) \
if (content == #string) { \ if (content == #string) { \

21
query.h Normal file
View File

@ -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
};

111
task.cc Normal file
View File

@ -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;
}

1
third_party/tiny-process-library vendored Submodule

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