README_en.md

中文 | English Readme

CGraph Readme

1. Introduction

CGraph, short for Color Graph, is a cross-platform DAG computing framework without any third-party dependencies. With the scheduling via GPipeline, the purpose of sequential and concurrent executing elements is realized.

You only need to inherit GNode class, implement the run() method in the subclass, and set the dependencies as needed to achieve the graphical execution of tasks.

At the same time, you can also control the graph conditional judgment, loop or concurrent execution logic by setting various GGroups, which containing multi-node information by themselves.

You can transfer your params in many scenes. It is also possible to extend the functions of the above elements horizontally by adding GAspect, or to enhance the functions of individual nodes by introducing various GAdapter.

2. Compile

• This project supports MacOS, Linux, and Windows systems without any third-party dependencies. C++11 is default and lowest version, C++17 is recommended.

• For developers using CLion as IDE within all platform, open the CMakeLists.txt file as project to compile.

• Developers on Windows system, using Visual Studio(2013 version at least) as IDE, with cmake, enter commands as flowers to build CGraph.sln file.

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

• Developers on Linux system, enter commands as flowers to compile.

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

• If you want to build it in docker, image based on Ubuntu 20.04 is provided.

  $ docker pull chunelfeng/cenv
  $ docker run -it --name CGraphEnv chunelfeng/cenv

• Compile online, enter CGraph env online, log in with your Github id, enter commands as flowers to compile and run your first tutorial.

  $ sudo apt-get install cmake
  $ ./CGraph-build.sh
  $ ./build/tutorial/T00-HelloCGraph

3. Demo

MyNode.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;
    }
};


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 "MyNode.h"

using namespace CGraph;

int main() {
    /* build a pipeline */
    GPipelinePtr pipeline = GPipelineFactory::create();
    GElementPtr a, b, c, d = nullptr;

    /* register node with dependency info */
    CStatus status = pipeline->registerGElement<MyNode1>(&a, {}, "nodeA");    // register nodeA with no dependency
    status += pipeline->registerGElement<MyNode2>(&b, {a}, "nodeB");    // b depends a
    status += pipeline->registerGElement<MyNode1>(&c, {a}, "nodeC");
    status += pipeline->registerGElement<MyNode2>(&d, {b, c}, "nodeD");    // d depends b and c
    if (!status.isOK()) {
        return;
    }

    /* run dag pipeline */
    status = pipeline->process();
    GPipelineFactory::remove(pipeline);

    return 0;
}

As is shown on the picture, run a firstly. Then, run b and c parallelized. Run d at last after b and c finished.