OlapOnDB API

extern "C" bool Process(GraphDB & db, const std::string & request, std::string & response) {

    // Obtain the number of iterations from web side requests (num_iterations)，
    int num_iterations = 20;
    try {
        json input = json::parse(request);
        num_iterations = input["num_iterations"].get<int>();
    } catch (std::exception & e) {
        throw std::runtime_error("json parse error");
        return false;
    }

    // Read transaction creation and snapshot class creation
    auto txn = db.CreateReadTxn();
    OlapOnDB<Empty> olapondb(
        db,
        txn,
        SNAPSHOT_PARALLEL
    );

    // Create a pr array to store the pr value for each node
    ParallelVector<double> pr = olapondb.AllocVertexArray<double>();
    // pagerank algorithm main process, obtain the pagerank value of each node
    PageRankCore(olapondb, num_iterations, pr);

    auto all_vertices = olapondb.AllocVertexSubset();
    all_vertices.Fill();
    /*
        Function Purpose: Gets the number of the node with the largest pagerank among all nodes

        Function flow description: This function executes Func A for node vi (also known as the active vertices) corresponding to all bits of 1 in the vertex set all_vertices. The return value of Func A is then used as the second input parameter of Func B to obtain the local maximum value (because the first input parameter is 0. So the return value is actually the pagerank value of each node). Finally, the return value of all threads is summarized, and Func B is executed again to get the global return value, and stored in the max_pr_vi variable
    */
    size_t max_pr_vi = olapondb.ProcessVertexActive<size_t>(

        //Func A
        [&](size_t vi) {
            return vi;
        },
        all_vertices,
        0,

        //Func B
        [&](size_t a, size_t b) {
            return pr[a] > pr[b] ? a : b;
        }
    );

    // Retrieve and send the return value from the web page
    json output;
    output["max_pr_vid"] = olapondb.OriginalVid(max_pr_vi);
    output["max_pr_val"] = pr[max_pr_vi];
    response = output.dump();
    return true;
}

void PageRankCore(OlapBase<Empty>& graph, int num_iterations, ParallelVector<double>& curr) {

    // Initialization of related data structures
    auto all_vertices = olapondb.AllocVertexSubset();
    all_vertices.Fill();
    auto curr = olapondb.AllocVertexArray<double>();
    auto next = olapondb.AllocVertexArray<double>();
    size_t num_vertices = olapondb.NumVertices();
    double one_over_n = (double)1 / num_vertices;

    // The initialization of the pagerank value of each node is inversely proportional to the degree of the node
    double delta = graph.ProcessVertexActive<double>(
        [&](size_t vi) {
            curr[vi] = one_over_n;
            if (olapondb.OutDegree(vi) > 0) {
                curr[vi] /= olapondb.OutDegree(vi);
            }
            return one_over_n;
        },
        all_vertices);

    // Total iteration process
    double d = (double)0.85;
        for (int ii = 0;ii < num_iterations;ii ++) {
        printf("delta(%d)=%lf\n", ii, delta);
        next.Fill((double)0);

        /*
            Function Purpose: Calculates the pagerank of all nodes

            Function flow description: This function is used to calculate the pagerank value of all nodes. Execute Func C on node vi corresponding to all the bits of 1 in all_vertices to obtain the pagerank value of vi in the current iteration and return the pagerank change value of vi node. The total change value of all active nodes is finally summarized and returned through the internal processing of the function, which is stored in the delta variable
        */
        delta = graph.ProcessVertexActive<double>(
            // Func C
            [&](size_t vi) {
                double sum = 0;

                // Gets the pagerank value of the current node from its neighbor
                for (auto & edge : olapondb.InEdges(vi)) {
                    size_t src = edge.neighbour;
                    sum += curr[src];
                }
                next[vi] = sum;

                // pagerank value calculation core formula
                next[vi] = (1 - d) * one_over_n + d * next[vi];
                if (ii == num_iterations - 1) {
                    return (double)0;
                } else {

                    // Statistics of relevant intermediate variables
                    if (olapondb.OutDegree(vi) > 0) {
                        next[vi] /= olapondb.OutDegree(vi);
                        return fabs(next[vi] - curr[vi]) * olapondb.OutDegree(vi);
                    } else {
                        return fabs(next[vi] - curr[vi]);
                    }
                }
            },
            all_vertices
        );

        // The pagerank value obtained in this iteration is output as the input of the next iteration
        curr.Swap(next);
    }
}

// Create a read transaction
auto txn = db.CreateReadTxn();

// Write transaction creation
auto txn = db.CreateWriteTxn();

OlapOnDB<empty> olapondb(</empty>
db,
txn,
SNAPSHOT_PARALLEL
)

OlapOnDB<empty> olapondb(</empty>
db,
txn,
SNAPSHOT_PARALLEL | SNAPSHOT_UNDIRECTED;
)

size_t OutDegree(size_t vid)

size_t InDegree(size_t vid)

/*
    Function name: AdjList OutEdges(size_t vid)

    Data structure:

    An AdjList can be understood as an array of structures of type AdjUnit

    AdjUnit has two member variables: 1. size_t neighbour 2. edge_data: neighbour indicates the number of the target node pointed by the outgoing edge. If the value is a licensed graph, the data type of edge_data is the same as the weight value of the edge in the input file

    Example Output all outgoing neighbors of node vid
*/
for (auto & edge : olapondb.OutEdges(vid)) {
    size_t dst = edge.neighbour;
    printf("src = %lu,dst = %lu\n",vid,dst);
}

AdjList<edgedata> InEdges(size_t vid)</edgedata>

// Example: Outputs all inbound neighbors of node vid
for (auto & edge : olapondb.InEdges(vid)) {
size_t dst = edge.neighbour;
printf("src = %lu,dst = %lu\n",vid,dst);
}

size_t OriginalVid(size_t vid)

// Note: The node numbers entered in TuGraph can be non-numbers, such as names. When OlapOnDB subgraphs are generated, names and other names will be converted to numbers for subsequent processing. Therefore, this method may not be applicable to some specific scenarios

size_t MappedVid(size_t original_vid)

ParallelBitset temp = 000111; // The current active vertices are vertices 3, 4 and 5

size_t delta = ForEachActiveVertex<double>(</double>
//void c
[&](size_t vi) {
printf("active_vertexId = %lu\n",vi);
return 1;
},
all_vertices
);

active_vertexId = 3
active_vertexId = 4
active_vertexId = 5