CGraph Documentation

To use the Python version of CGraph (pycgraph):

1. Inherit from GNode: Create a subclass of GNode and implement the run() method. The method should return a CStatus() object.
2. Initialize Pipeline: Create a GPipeline() instance.
3. Register Elements: Use pipeline.registerGElement(node_instance, dependency_set, name) to define nodes and their dependencies. Dependencies are passed as a set of node instances.
4. Execute: Call pipeline.process() to run the graph.

import time
from datetime import datetime
from pycgraph import GNode, GPipeline, CStatus

class MyNode1(GNode):
    def run(self):
        print("[{0}] {1}, enter MyNode1 run function. Sleep for 1 second ... ".format(datetime.now(), self.getName()))
        time.sleep(1)
        return CStatus()

class MyNode2(GNode):
    def run(self):
        print("[{0}] {1}, enter MyNode2 run function. Sleep for 2 second ... ".format(datetime.now(), self.getName()))
        time.sleep(2)
        return CStatus()

if __name__ == '__main__':
    pipeline = GPipeline()
    a, b, c, d = MyNode1(), MyNode2(), MyNode1(), MyNode2()

    pipeline.registerGElement(a, set(), "nodeA")
    pipeline.registerGElement(b, {a}, "nodeB")
    pipeline.registerGElement(c, {a}, "nodeC")
    pipeline.registerGElement(d, {b, c}, "nodeD")

    pipeline.process()

CGraph supports MacOS, Linux, Windows, and Android with no third-party dependencies. It defaults to C++11, but C++17 is recommended. It does not support versions below C++11.

IDE Setup

• CLion (Recommended): Open the CMakeLists.txt file directly as a project.
• Visual Studio (Windows): Use CMake to generate a .sln file.
• Xcode (MacOS): Use CMake to generate an .xcodeproj file.

Build Systems

You can build CGraph using CMake, Bazel, or Xmake.

### Windows (Visual Studio)
$ git clone https://github.com/ChunelFeng/CGraph.git
$ cd CGraph
$ cmake . -Bbuild

### MacOS (Xcode)
$ git clone https://github.com/ChunelFeng/CGraph.git
$ cd CGraph
$ mkdir build && cd build
$ cmake .. -G Xcode

### CMake (Linux/MacOS/Windows)
$ git clone https://github.com/ChunelFeng/CGraph.git
$ cd CGraph
$ cmake . -Bbuild
$ cd build && make -j8
$ ./tutorial/T00-HelloCGraph

### Bazel (Linux/MacOS/Windows)
$ git clone https://github.com/ChunelFeng/CGraph.git
$ cd CGraph
$ bazel build //tutorial/...
$ bazel run //tutorial:T00-HelloCGraph

### Xmake (Linux/MacOS/Windows)
$ git clone https://github.com/ChunelFeng/CGraph.git
$ cd CGraph
$ xmake build
$ xmake run T00-HelloCGraph

To use CGraph in C++, follow these steps:

1. Inherit from GNode: Create a subclass of GNode and implement the run() method. The run() method should return a CStatus object.
2. Create a Pipeline: Use GPipelineFactory::create() to instantiate a GPipelinePtr.
3. Register Elements and Dependencies: Use pipeline->registerGElement<T>(element_ptr, dependencies, name) to add nodes to the graph and define their execution order. Dependencies are passed as a list of pointers to previously registered elements.
4. Execute: Call pipeline->process() to start the graph execution.
5. Cleanup: Call GPipelineFactory::remove(pipeline) to release resources.

#include "CGraph.h"

using namespace CGraph;

class MyNode1 : public GNode {
public:
    CStatus run() override {
        printf("[%s], sleep for 1 second ...\n", this->getName().c_str());
        CGRAPH_SLEEP_SECOND(1)
        return CStatus();
    }
};

class MyNode2 : public GNode {
public:
    CStatus run() override {
        printf("[%s], sleep for 2 second ...\n", this->getName().c_str());
        CGRAPH_SLEEP_SECOND(2)
        return CStatus();
    }
};

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

    /* Register dependencies between nodes */
    pipeline->registerGElement<MyNode1>(&a, {}, "nodeA");
    pipeline->registerGElement<MyNode2>(&b, {a}, "nodeB");
    pipeline->registerGElement<MyNode1>(&c, {a}, "nodeC");
    pipeline->registerGElement<MyNode2>(&d, {b, c}, "nodeD");

    /* Execute the graph flow framework */
    pipeline->process();

    /* Clear all resources in the pipeline */
    GPipelineFactory::remove(pipeline);

    return 0;
}

The UThreadPool class provides a mechanism for managing a pool of threads to execute tasks in parallel. It supports different task submission strategies, including priority-based execution, specific thread targeting, and task groups.

Lifecycle

1. Construction: Create an instance using UThreadPool(CBool autoInit = true, const UThreadPoolConfig& config = UThreadPoolConfig()). If autoInit is true, the pool starts immediately.
2. Configuration: Use setConfig(const UThreadPoolConfig &config) to modify settings. Note: This must be called before init(). If using the UThreadPoolSingleton, you must call destroy() before setting new parameters.
3. Initialization: Call init() to start all threads. Check status with isInit().
4. Execution: Submit tasks using commit, execute, or submit (see below).
5. Cleanup: Call destroy() to release all thread resources.