面向云代理会话的 VS Code 中的检查点

Author: Nianle-Li

cmake-3.28.1-linux-x86_64.sh.1

@@ -71,59 +71,90 @@ py::list _weighted_triangles_and_degree(py::object G, py::object nodes, py::obje
 	}
 
 	size_t compact_size = adj_vectors.size();
-	
-	#pragma omp parallel
-	{
-		std::vector<char> mark(compact_size, 0);
-		
-		#pragma omp for schedule(dynamic, 64) nowait
-		for (int idx = 0; idx < n; ++idx) {
-			node_t i_id = node_ids[idx];
-			size_t i_compact = node_to_compact_idx[i_id];
-			const auto& nbrs = adj_vectors[i_compact];
-			int m = nbrs.size();
-			
-			if (m < 2) {
-				results[idx] = std::make_tuple(i_id, m, 0.0);
-				continue;
-			}
-			
-			// 标记邻居
-			for (node_t v : nbrs) {
-				if (node_to_compact_idx.count(v)) {
-					mark[node_to_compact_idx[v]] = 1;
-				}
-			}
-			
-			weight_t weighted_triangles = 0;
-			for (int a = 0; a < m; ++a) {
-				node_t j_id = nbrs[a];
-				if (!node_to_compact_idx.count(j_id)) continue;
-				
-				weight_t wij = wt(adj, i_id, j_id, weight_key, max_weight);
-				size_t j_compact = node_to_compact_idx[j_id];
-				const auto& j_nbrs = adj_vectors[j_compact];
-				
-				for (node_t k_id : j_nbrs) {
-					if (k_id > j_id && node_to_compact_idx.count(k_id) && mark[node_to_compact_idx[k_id]]) {
-						weight_t wjk = wt(adj, j_id, k_id, weight_key, max_weight);
-						weight_t wki = wt(adj, k_id, i_id, weight_key, max_weight);
-						weighted_triangles += std::cbrt(wij * wjk * wki);
-					}
-				}
+
+	// degree-ordering: compute degree and rank for compact indices
+	std::vector<size_t> deg(compact_size);
+	for (size_t i = 0; i < compact_size; ++i) deg[i] = adj_vectors[i].size();
+	std::vector<size_t> idxs(compact_size);
+	for (size_t i = 0; i < compact_size; ++i) idxs[i] = i;
+	std::sort(idxs.begin(), idxs.end(), [&](size_t a, size_t b) {
+		if (deg[a] != deg[b]) return deg[a] < deg[b];
+		return a < b;
+	});
+	std::vector<size_t> rank(compact_size);
+	for (size_t i = 0; i < compact_size; ++i) rank[idxs[i]] = i;
+
+	// create mapping compact_idx -> original node id for fast lookup
+	std::vector<node_t> compact_to_node(compact_size);
+	for (const auto &p : node_to_compact_idx) compact_to_node[p.second] = p.first;
+
+	// build oriented adjacency (from lower rank -> higher rank)
+	std::vector<std::vector<size_t>> out_adj(compact_size);
+	std::vector<std::vector<weight_t>> out_w(compact_size);
+	for (size_t u_c = 0; u_c < compact_size; ++u_c) {
+		const auto &nbrs = adj_vectors[u_c];
+		node_t u_orig = compact_to_node[u_c];
+		for (node_t v_id : nbrs) {
+			auto it = node_to_compact_idx.find(v_id);
+			if (it == node_to_compact_idx.end()) continue;
+			size_t v_c = it->second;
+			if (rank[u_c] < rank[v_c]) {
+				out_adj[u_c].push_back(v_c);
 			}
-			
-			// 清除标记
-			for (node_t v : nbrs) {
-				if (node_to_compact_idx.count(v)) {
-					mark[node_to_compact_idx[v]] = 0;
+		}
+	}
+
+	// Precompute weight cbrt per oriented edge using adjacency lookups; also sort neighbor lists
+	for (size_t u_c = 0; u_c < compact_size; ++u_c) {
+		auto &nbrs = out_adj[u_c];
+		std::sort(nbrs.begin(), nbrs.end());
+		auto &wvec = out_w[u_c];
+		wvec.reserve(nbrs.size());
+		node_t u_orig = compact_to_node[u_c];
+		for (size_t v_c : nbrs) {
+			node_t v_orig = compact_to_node[v_c];
+			weight_t w = wt(adj, u_orig, v_orig, weight_key, max_weight);
+			wvec.push_back(std::cbrt(w));
+		}
+	}
+
+	// triangle accumulation (each triangle counted once); store contributions per compact node
+	std::vector<weight_t> tri_contrib(compact_size, 0.0);
+	for (size_t u_c = 0; u_c < compact_size; ++u_c) {
+		const auto &out_u = out_adj[u_c];
+		const auto &w_u = out_w[u_c];
+		for (size_t iu = 0; iu < out_u.size(); ++iu) {
+			size_t v_c = out_u[iu];
+			const auto &out_v = out_adj[v_c];
+			const auto &w_v = out_w[v_c];
+			size_t p = 0, q = 0;
+			while (p < out_u.size() && q < out_v.size()) {
+				if (out_u[p] < out_v[q]) ++p;
+				else if (out_v[q] < out_u[p]) ++q;
+				else {
+					size_t w_c = out_u[p];
+					weight_t w_uv = w_u[iu];
+					weight_t w_uw = w_u[p];
+					weight_t w_vw = w_v[q];
+					weight_t contrib = w_uv * w_vw * w_uw; // product of cbrts equals cbrt(product)
+					tri_contrib[u_c] += contrib;
+					tri_contrib[v_c] += contrib;
+					tri_contrib[w_c] += contrib;
+					++p; ++q;
 				}
 			}
-			
-			results[idx] = std::make_tuple(i_id, m, 2 * weighted_triangles);
 		}
 	}
 
+	// build results for requested nodes
+	#pragma omp parallel for schedule(static)
+	for (int idx = 0; idx < n; ++idx) {
+		node_t id = node_ids[idx];
+		size_t c = node_to_compact_idx[id];
+		int m = adj_vectors[c].size();
+		results[idx] = std::make_tuple(id, m, 2 * tri_contrib[c]);
+	}
+
 	py::list ret;
 	for (int i = 0; i < n; ++i) {
 		ret.append(py::make_tuple(G_.id_to_node[py::cast(std::get<0>(results[i]))], 
@@ -173,55 +204,64 @@ py::list _triangles_and_degree(py::object G, py::object nodes = py::none()) {
 	}
 
 	size_t compact_size = adj_vectors.size();
-	
-	#pragma omp parallel
-	{
-		std::vector<char> mark(compact_size, 0);
-		
-		#pragma omp for schedule(dynamic, 64) nowait
-		for (int idx = 0; idx < n; ++idx) {
-			node_t v = node_ids[idx];
-			size_t v_compact = node_to_compact_idx[v];
-			const auto& nbrs = adj_vectors[v_compact];
-			int m = nbrs.size();
-			
-			if (m < 2) {
-				results[idx] = std::make_tuple(v, m, 0);
-				continue;
-			}
-			
-			// 标记邻居
-			for (node_t w : nbrs) {
-				if (node_to_compact_idx.count(w)) {
-					mark[node_to_compact_idx[w]] = 1;
-				}
-			}
-			
-			int64_t ntriangles = 0;
-			for (node_t wa : nbrs) {
-				if (!node_to_compact_idx.count(wa)) continue;
-				
-				size_t wa_compact = node_to_compact_idx[wa];
-				const auto& wa_nbrs = adj_vectors[wa_compact];
-				
-				for (node_t wb : wa_nbrs) {
-					if (wb > wa && node_to_compact_idx.count(wb) && mark[node_to_compact_idx[wb]]) {
-						++ntriangles;
-					}
-				}
-			}
-			
-			// 清除标记
-			for (node_t w : nbrs) {
-				if (node_to_compact_idx.count(w)) {
-					mark[node_to_compact_idx[w]] = 0;
+
+	// degree-ordering and oriented adjacency for unweighted triangle counting
+	std::vector<size_t> deg(compact_size);
+	for (size_t i = 0; i < compact_size; ++i) deg[i] = adj_vectors[i].size();
+	std::vector<size_t> idxs(compact_size);
+	for (size_t i = 0; i < compact_size; ++i) idxs[i] = i;
+	std::sort(idxs.begin(), idxs.end(), [&](size_t a, size_t b) {
+		if (deg[a] != deg[b]) return deg[a] < deg[b];
+		return a < b;
+	});
+	std::vector<size_t> rank(compact_size);
+	for (size_t i = 0; i < compact_size; ++i) rank[idxs[i]] = i;
+
+	std::vector<node_t> compact_to_node(compact_size);
+	for (const auto &p : node_to_compact_idx) compact_to_node[p.second] = p.first;
+
+	std::vector<std::vector<size_t>> out_adj(compact_size);
+	for (size_t u_c = 0; u_c < compact_size; ++u_c) {
+		node_t u_orig = compact_to_node[u_c];
+		for (node_t v_id : adj_vectors[u_c]) {
+			auto it = node_to_compact_idx.find(v_id);
+			if (it == node_to_compact_idx.end()) continue;
+			size_t v_c = it->second;
+			if (rank[u_c] < rank[v_c]) out_adj[u_c].push_back(v_c);
+		}
+		std::sort(out_adj[u_c].begin(), out_adj[u_c].end());
+	}
+
+	std::vector<int64_t> tri_count(compact_size, 0);
+	for (size_t u_c = 0; u_c < compact_size; ++u_c) {
+		const auto &out_u = out_adj[u_c];
+		for (size_t i_u = 0; i_u < out_u.size(); ++i_u) {
+			size_t v_c = out_u[i_u];
+			const auto &out_v = out_adj[v_c];
+			size_t p = 0, q = 0;
+			while (p < out_u.size() && q < out_v.size()) {
+				if (out_u[p] < out_v[q]) ++p;
+				else if (out_v[q] < out_u[p]) ++q;
+				else {
+					size_t w_c = out_u[p];
+					++tri_count[u_c];
+					++tri_count[v_c];
+					++tri_count[w_c];
+					++p; ++q;
 				}
 			}
-			
-			results[idx] = std::make_tuple(v, m, ntriangles);
 		}
 	}
 
+	// build results for requested nodes
+	#pragma omp parallel for schedule(static)
+	for (int idx = 0; idx < n; ++idx) {
+		node_t v = node_ids[idx];
+		size_t v_c = node_to_compact_idx[v];
+		int m = adj_vectors[v_c].size();
+		results[idx] = std::make_tuple(v, m, tri_count[v_c]);
+	}
+
 	py::list ret;
 	for (int i = 0; i < n; ++i) {
 		ret.append(py::make_tuple(G_.id_to_node[py::cast(std::get<0>(results[i]))],