pdclab / graphbolt Goto Github PK

Dear authors,
Thank you for sharing the code
I have read the paper of incremental systems "GraphBolt"and"DZIG" carefully , then I have a question that is
SSSP algorithms in DZIG and GraphBolt are both implelementioned by kickstarter engine,is the kickstarter engine the same on GraphBolt and DZIG systems?

I am trying to limit the number of workers with -nWorkers parameter, but regardless of the number I set, the GraphBolt uses all the cores available on the machine.

Hi!

Is it possible to print the results from the initial computation and the results computed incrementally?

Thanks.

When I run this code, there is an error: "Disabled horizontal and vertical pruning", and then "segmentation fault (core dumped)". There is no source code, I can not debug it.

Hi there,

I'm trying to implement the connected-component algorithm based on KickStarter engine. But the length of data type is limited to 16 bits. Because the KickStarterEngine uses "DependencyData" to hold the data,

  template <class T> struct DependencyData {
    uintV parent;
    T value;
    uint16_t level;
    ....
}

The instruct __sync_bool_compare_and_swap is used to ensure the correctness of the parallel update. But unfortunately, 128 bits CAS looks lack support in the Kickstarter.

template <class ET> inline bool CAS(ET *ptr, ET oldv, ET newv) {
  if (sizeof(ET) == 1) {
    return __sync_bool_compare_and_swap((bool *)ptr, *((bool *)&oldv),
                                        *((bool *)&newv));
  } else if (sizeof(ET) == 4) {
    return __sync_bool_compare_and_swap((int *)ptr, *((int *)&oldv),
                                        *((int *)&newv));
  } else if (sizeof(ET) == 8) {
    return __sync_bool_compare_and_swap((long *)ptr, *((long *)&oldv),
                                        *((long *)&newv));
  } else {
    std::cout << "CAS bad length : " << sizeof(ET) << std::endl;
    abort();
  }
}

May I have a suggestion to modify the project to support a longer data type?

Thanks,
Liang

Hi!
Thank you for sharing the code!
I have read the paper "GraphBolt" carefully and found that for non-decomposable aggregations, the aggregated value cannot be incrementally adjusted to remove an old contribution. There is a different formulation to compute non-decomposable aggregations.
I want to implement SSSP using the GraphBolt engine, but in the repository, SSSP is implemented using the KickStarter engine. And it seems to be difficult to implement it using the provided GraphBolt engine.
Could you provide the SSSP code using GraphBolt engine or give me some advice?
Looking forward to your reply!

Recently, I read your paper "GraphBolt: Dependency-Driven Synchronous Processing of Streaming Graphs". I am very interested in it. GraphBolt incrementally processes streaming graphs while guaranteeing BSP semantics. The proposed dependency-driven incremental processing framework is an innovative and novel work. Now, I am trying to run PageRank algorithm with GraphBolt on my PC (8core, 64G memory, Ubuntu 18.04, GCC 5.5). The dataset is Google dataSet with 900k vertices. But it throws a segmentation fault. When I run PageRank with a smaller dataSet (with 4k vertices), it succeeds. I don't know why, and I am not familiar with mi_malloc. Whether I need to configure something in the execution script, your source code, or my PC system? So that mi_malloc can malloc larger memory. Looking forward to your reply.

Dear authors
Thank you for sharing the code!
I have read the paper "DZiG" and "Graphbolt" carefully, and I noticed that your adaptive execution model is based on linear regression. I tried to run your code ,but I can't get a good result. The R^2 value I get is not as good as the paper mentioned. I wonder if you can provide the original data of the experiment, thanks a lot