/n

Author: adish29

.gitignore

@@ -1,4 +1,6 @@
 *.exe
 *.in
 *.out
-*.o
+*.o
+*.exp
+*.lib

CPU/vector_initialize.h

@@ -3,7 +3,7 @@
 
 #include <vector>
 #include <cmath>
-#include <omp.h>
+#include "omp.h"
 
 struct Item {
     Item(std::vector<double> _values) : values(_values) {}
@@ -54,7 +54,6 @@ struct Item {
 
     double cosine_similarity_with_normalisation(Item& other) {
         double dot_product = 0.0;
-        // #pragma omp parallel for reduction(+:dot_product)
         for (size_t i = 0; i < values.size(); ++i) {
             dot_product += values[i] * other.values[i];
         }

compile.sh

@@ -1,3 +1,4 @@
 g++ -c -fopenmp main.cpp -o main.o
 g++ -c -fopenmp hnsw_implementation/hnsw.cpp -o hnsw.o
-g++ main.o hnsw.o -o my_program
+g++ -fopenmp main.o hnsw.o -o my_program
+nvcc GPU/ann.cu -o nn -O3 -arch=sm_60

hnsw_implementation/hnsw.cpp

@@ -10,29 +10,37 @@
 #include <omp.h>
 using namespace std;
 
-vector<int> HNSWGraph::searchLayer(Item& q, int ep, int ef, int lc) {
+vector<int> HNSWGraph::searchLayer(Item& q, int entry_point, int ef, int lc) {
 	set<pair<double, int>> candidates;
 	set<pair<double, int>> nearestNeighbors;
 	unordered_set<int> isVisited;
 
-	double td = q.dist(items[ep]);
-	candidates.insert(make_pair(td, ep));
-	nearestNeighbors.insert(make_pair(td, ep));
-	isVisited.insert(ep);
+	double td = q.dist(items[entry_point]);
+	candidates.insert(make_pair(td, entry_point));
+	nearestNeighbors.insert(make_pair(td, entry_point));
+	isVisited.insert(entry_point);
 	while (!candidates.empty()) {
-		auto ci = candidates.begin(); candidates.erase(candidates.begin());
+		auto ci = candidates.begin(); 
+		candidates.erase(candidates.begin());
 		int nid = ci->second;
 		auto fi = nearestNeighbors.end(); fi--;
-		if (ci->first > fi->first) break;
+		if (ci->first > fi->first) {
+			break;
+		}
 		for (int ed: layerEdgeLists[lc][nid]) {
-			if (isVisited.find(ed) != isVisited.end()) continue;
-			fi = nearestNeighbors.end(); fi--;
+			if (isVisited.find(ed) != isVisited.end()) {
+				continue;
+			}
+			fi = nearestNeighbors.end(); 
+			fi--;
 			isVisited.insert(ed);
 			td = q.dist(items[ed]);
 			if ((td < fi->first) || nearestNeighbors.size() < ef) {
 				candidates.insert(make_pair(td, ed));
 				nearestNeighbors.insert(make_pair(td, ed));
-				if (nearestNeighbors.size() > ef) nearestNeighbors.erase(fi);
+				if (nearestNeighbors.size() > ef) {
+					nearestNeighbors.erase(fi);
+				}
 			}
 		}
 	}
@@ -43,50 +51,65 @@ vector<int> HNSWGraph::searchLayer(Item& q, int ep, int ef, int lc) {
 
 vector<int> HNSWGraph::KNNSearch(Item& q, int K) {
 	int maxLyer = layerEdgeLists.size() - 1;
-	int ep = enterNode;
-	for (int l = maxLyer; l >= 1; l--) ep = searchLayer(q, ep, 1, l)[0];
-	return searchLayer(q, ep, K, 0);
+	int entry_point = enterNode;
+	for (int l = maxLyer; l >= 1; l--) {
+		entry_point = searchLayer(q, entry_point, 1, l)[0];
+	}
+	return searchLayer(q, entry_point, K, 0);
 }
 
 void HNSWGraph::addEdge(int st, int ed, int lc) {
-	if (st == ed) return;
+	if (st == ed) {
+		return;
+	}
 	layerEdgeLists[lc][st].push_back(ed);
 	layerEdgeLists[lc][ed].push_back(st);
 }
 
 void HNSWGraph::Insert(Item& q) {
 	int nid = items.size();
 	itemNum++; items.push_back(q);
-	// sample layer
 	int maxLyer = layerEdgeLists.size() - 1;
 	int l = 0;
 	uniform_real_distribution<double> distribution(0.0,1.0);
 	while(l < ml && (1.0 / ml <= distribution(generator))) {
 		l++;
-		if (layerEdgeLists.size() <= l) layerEdgeLists.push_back(unordered_map<int, vector<int>>());
+		if (layerEdgeLists.size() <= l) {
+			layerEdgeLists.push_back(unordered_map<int, vector<int>>());
+		}
 	}
 	if (nid == 0) {
 		enterNode = nid;
 		return;
 	}
-	// search up layer entrance
-	int ep = enterNode;
-	for (int i = maxLyer; i > l; i--) ep = searchLayer(q, ep, 1, i)[0];
+	int entry_point = enterNode;
+	for (int i = maxLyer; i > l; i--) {
+		entry_point = searchLayer(q, entry_point, 1, i)[0];
+	}
+	#pragma omp parallel for
 	for (int i = min(l, maxLyer); i >= 0; i--) {
 		int MM = l == 0 ? MMax0 : MMax;
-		vector<int> neighbors = searchLayer(q, ep, efConstruction, i);
+		vector<int> neighbors = searchLayer(q, entry_point, efConstruction, i);
 		vector<int> selectedNeighbors = vector<int>(neighbors.begin(), neighbors.begin()+min(int(neighbors.size()), M));
-		for (int n: selectedNeighbors) addEdge(n, nid, i);
+		for (int n: selectedNeighbors) {
+			addEdge(n, nid, i);
+		}
 		for (int n: selectedNeighbors) {
 			if (layerEdgeLists[i][n].size() > MM) {
 				vector<pair<double, int>> distPairs;
-				for (int nn: layerEdgeLists[i][n]) distPairs.emplace_back(items[n].dist(items[nn]), nn);
+				for (int nn: layerEdgeLists[i][n]) {
+					distPairs.emplace_back(items[n].dist(items[nn]), nn);
+				}
 				sort(distPairs.begin(), distPairs.end());
 				layerEdgeLists[i][n].clear();
-				for (int d = 0; d < min(int(distPairs.size()), MM); d++) layerEdgeLists[i][n].push_back(distPairs[d].second);
+				for (int d = 0; d < min(int(distPairs.size()), MM); d++) {
+					layerEdgeLists[i][n].push_back(distPairs[d].second);
+				}
 			}
 		}
-		ep = selectedNeighbors[0];
+		entry_point = selectedNeighbors[0];
+	}
+	if (l == layerEdgeLists.size() - 1) {
+		enterNode = nid;
 	}
-	if (l == layerEdgeLists.size() - 1) enterNode = nid;
 }

hnsw_implementation/hnsw.h

@@ -5,7 +5,6 @@
 #include <vector>
 #include <unordered_map>
 #include <iostream>
-#include <omp.h>
 
 #include "../CPU/vector_initialize.h"
 using namespace std;

main.cpp

@@ -8,7 +8,6 @@
 #include <memory>
 #include <string>
 #include <sstream>
-#include <omp.h>
 using namespace std;
 
 void readInputFromFile(const string& filename, int& D, int& N, int& M, vector<Item>& base, vector<Item>& queries) {
@@ -129,8 +128,15 @@ int main(int argc, char* argv[]) {
         outfile << endl;
         total_hnsw_time += double(clock() - begin_time) / CLOCKS_PER_SEC;
 
-        if (knns[0] == distPairs[0].second) numHits++;
+        if (knns[0] == distPairs[0].second) {
+            numHits++;
+        }
     }
+    
+
+    // myHNSWGraph.printGraph(); //Uncomment to visualize graph layers
+
+
     for (Item& item : base) {
         item.normalize();
     }