This issue recommends CGraph, an open source parallel computing framework based on flow graphs.

This project implements a cross-platform graph flow calculation framework without any third-party dependence. Through the low-level scheduling of GPipeline (pipeline), the scheduling function of sequential execution of dependent elements and concurrent execution of non-dependent elements is realized.

The user only needs to inherit the GNode (node) class, implement the run() method of the subclass, and set the dependency as needed, to achieve the graphical execution of the task.

At the same time, the user can also control the conditional judgment, loop and concurrent execution logic of the graph by setting various Ggroups (groups) containing multi-node information.

In addition, the function of the above elements can be extended horizontally by adding GAspect (section), or the function of a single node can be strengthened by introducing various Gadapters.

Compilation Instructions

• This project supports MacOS, Linux, and Windows without any third-party dependence. Developers using CLion as an IDE, open the CMakeLists.txt file as a project, you can compile through.
• Linux environment developer, in the command line mode, enter the following command, you can compile through.

$ git clone https://github.com/ChunelFeng/CGraph.git
$ cd CGraph
$ cmake . -Bbuild
$ cd build
$ make -j8

• In the Windows environment, developers using Visual Studio as the IDE, please set the newline type before clone this project.

$ git config --global core.autocrlf true    # Sets the CRLF line break form supported by the Windows platform 
$ git clone https://github.com/ChunelFeng/CGraph.git
$... ... # Next operation with Linux command line environment, you can generate the corresponding *.sln file 

• Provides Docker images based on Ubuntu 20.04.3. Enter the following command to obtain and enter.

$ docker pull chunelfeng/cenv                         # Get docker image 
$docker run-it --name CGraphEnv chunelfeng/cenv # Open the docker container and go to 

< li data – track = “17” > offers the online version of the compiler debugging environment, click into the page: https://gitpod.io/#/github.com/ChunelFeng/CGraph, enter the following command, can be compiled through, and view the execution results.

$./ cgraph-build. sh # Compile the CGraph project, The generated content is in the sibling /build/ folder 
$./build/T00-HelloCGraph # Run the first instance program, And in the terminal output Hello, CGraph.

Using DEMO

MyNode1.h

#include ".. /.. /src/CGraph.h"

class MyNode1 : public CGraph::GNode {
public:
CStatus run () override {
CStatus status;
CGraph::CGRAPH_ECHO("[%s], enter MyNode1 run function. Sleep for 1 second ...  ", this-> getName().c_str());
CGRAPH_SLEEP_SECOND(1)
return status;
}
}; 

MyNode2.h

#include ".. /.. /src/CGraph.h"

class MyNode2 : public CGraph::GNode {
public:
CStatus run () override {
CStatus status;
CGraph::CGRAPH_ECHO("[%s], enter MyNode2 run function. Sleep for 2 second ...  ", this-> getName().c_str());
CGRAPH_SLEEP_SECOND(2)
return status;
}
}; 

main.cpp

#include "MyGNode/MyNode1.h"
#include "MyGNode/MyNode2.h"

using namespace CGraph;

int main() {
/* Creates a pipeline for setting up and executing flow graph information */
GPipelinePtr pipeline = GPipelineFactory::create();
GElementPtr a, b, c, d = nullptr;

/* Registers nodes, where MyNode1 and MyNode2 must be subclasses of GNode, otherwise they will not compile */
CStatus status = pipeline-> registerGElement< MyNode1> (& a, {}, "nodeA");     // Register node information named nodeA without execution dependencies into the pipeline 
status += pipeline-> registerGElement< MyNode2> (& b, {a}, "nodeB");     // Register nodeB in the pipeline, depending on the node information executed by a 
    status += pipeline-> registerGElement< MyNode1> (& c, {a}, "nodeC");
status += pipeline-> registerGElement< MyNode2> (& d, {b, c}, "nodeD");     // Will be named nodeD, dependent on node information executed by {b,c}, registered in the pipeline 
if (! status.isOK()) {
return;     // Make a decision on the return values of all the above CGraph interfaces 
}

/* Execute flow graph framework */
status = pipeline-> process();
GPipelineFactory::remove(pipeline);

return 0;
}

As shown in the figure above, when the graph structure is executed, the a node is executed first. After node a is executed, nodes b and c are executed in parallel. After nodes b and c are executed, go to node d.

—END—

Open Source protocol: MIT