29 #ifndef DEF_GRAPHLAB_WRAPPERS
30 #define DEF_GRAPHLAB_WRAPPERS
34 using namespace graphchi;
69 template<
typename GraphType,
131 virtual size_t num_edges()
const { assert(
false);
return 0; }
143 virtual size_t procid()
const {
return (
size_t) omp_get_thread_num(); }
159 virtual std::ostream&
cout()
const {
return std::cout; }
175 virtual std::ostream&
cerr()
const {
return std::cerr; }
188 virtual size_t num_procs()
const {
return gcontext->execthreads; }
203 virtual int iteration()
const {
return gcontext->iteration; }
216 gcontext->last_iteration = gcontext->iteration;
239 gcontext->scheduler->add_task(vertex.
id());
255 gcontext->scheduler->add_task(gvid);
303 template <
typename GLVertexDataType,
typename EdgeDataType>
304 struct GraphLabVertexWrapper;
306 template <
typename GLVertexDataType,
typename EdgeDataType>
307 struct GraphLabEdgeWrapper;
311 template <
typename vertex_data,
typename edge_data>
317 typedef graphchi::vid_t vertex_id_type;
322 template<
typename Graph,
323 typename GatherType,
typename MessageType =
bool>
327 typedef typename Graph::vertex_data_type vertex_data_type;
328 typedef typename Graph::edge_data_type edge_data_type;
329 typedef GatherType gather_type;
330 typedef MessageType message_type;
333 typedef typename graphchi::vid_t vertex_id_type;
338 typedef graphlab::edge_dir_type edge_dir_type;
361 logstream(
LOG_FATAL) <<
"Gather not implemented!" << std::endl;
362 return gather_type();
369 virtual void apply(icontext_type& context,
389 logstream(
LOG_FATAL) <<
"Scatter not implemented!" << std::endl;
393 template <
typename GLVertexDataType,
typename EdgeDataType>
396 typedef GLVertexDataType vertex_data_type;
399 graphchi::vid_t vertexId;
401 std::vector<GLVertexDataType> * vertexArray;
404 std::vector<GLVertexDataType> * vertexArray): vertexId(vertexId),
405 vertex(vertex), vertexArray(vertexArray) { }
408 return vertexId == other.vertexId;
412 const vertex_data_type&
data()
const {
413 return (*vertexArray)[vertexId];
418 return (*vertexArray)[vertexId];
423 if (vertex == NULL) {
424 logstream(
LOG_ERROR) <<
"GraphChi does not support asking neighbor vertices in/out degrees." << std::endl;
427 return vertex->num_edges();
432 if (vertex == NULL) {
433 logstream(
LOG_ERROR) <<
"GraphChi does not support asking neighbor vertices in/out degrees." << std::endl;
436 return vertex->num_outedges();
440 graphchi::vid_t
id()
const {
454 template <
typename GLVertexDataType,
typename EdgeDataType>
457 typedef GLVertexDataType vertex_data_type;
458 typedef EdgeDataType edge_data_type;
463 std::vector<GLVertexDataType> * vertexArray;
467 std::vector<GLVertexDataType> * vertexArray,
bool is_inedge):
468 edge(edge), vertex(vertex), vertexArray(vertexArray), is_inedge(is_inedge) { }
515 const edge_data_type&
data()
const {
return const_cast<edge_data_type&
>(*edge->data_ptr); }
520 edge_data_type&
data() {
return *(edge->data_ptr); }
525 template <
class GraphLabVertexProgram>
528 typedef typename GraphLabVertexProgram::vertex_data_type GLVertexDataType;
529 typedef typename GraphLabVertexProgram::edge_data_type EdgeDataType;
530 typedef typename GraphLabVertexProgram::gather_type gather_type;
532 typedef typename GraphLabVertexProgram::message_type message_type;
534 std::vector<GLVertexDataType> * vertexInmemoryArray;
537 vertexInmemoryArray =
new std::vector<GLVertexDataType>();
544 if (gcontext.iteration == 0) {
545 logstream(
LOG_INFO) <<
"Initialize vertices in memory." << std::endl;
546 vertexInmemoryArray->resize(gcontext.nvertices);
576 GraphLabVertexProgram glVertexProgram;
579 glVertexProgram.init(glcontext, wrapperVertex,
typename GraphLabVertexProgram::message_type());
580 const GraphLabVertexProgram& const_vprog = glVertexProgram;
583 edge_dir_type gather_direction = const_vprog.gather_edges(glcontext, wrapperVertex);
587 switch (gather_direction) {
590 for(
int i=0; i < vertex.num_inedges(); i++) {
592 if (gathered > 0) sum += const_vprog.gather(glcontext, wrapperVertex, edgeWrapper);
593 else sum = const_vprog.gather(glcontext, wrapperVertex, edgeWrapper);
596 if (gather_direction != ALL_EDGES)
599 for(
int i=0; i < vertex.num_outedges(); i++) {
601 if (gathered > 0) sum += const_vprog.gather(glcontext, wrapperVertex, edgeWrapper);
602 else sum = const_vprog.gather(glcontext, wrapperVertex, edgeWrapper);
614 glVertexProgram.apply(glcontext, wrapperVertex, sum);
617 edge_dir_type scatter_direction = const_vprog.scatter_edges(glcontext, wrapperVertex);
619 switch(scatter_direction) {
622 for(
int i=0; i < vertex.num_inedges(); i++) {
624 const_vprog.scatter(glcontext, wrapperVertex, edgeWrapper);
626 if (scatter_direction != ALL_EDGES)
629 for(
int i=0; i < vertex.num_outedges(); i++) {
631 const_vprog.scatter(glcontext, wrapperVertex, edgeWrapper);
646 template <
typename GraphLabVertexProgram,
typename ReductionType,
647 typename EdgeMapType,
648 typename FinalizerType>
651 typedef typename GraphLabVertexProgram::vertex_data_type GLVertexDataType;
652 typedef typename GraphLabVertexProgram::edge_data_type EdgeDataType;
653 typedef typename GraphLabVertexProgram::edge_type edge_type;
654 typedef typename GraphLabVertexProgram::gather_type gather_type;
656 typedef typename GraphLabVertexProgram::message_type message_type;
659 std::vector<ReductionType> localaggr;
661 std::vector<GLVertexDataType> * vertexInmemoryArray;
662 EdgeMapType map_function;
663 FinalizerType finalize_function;
666 FinalizerType finalize_function,
667 std::vector<typename GraphLabVertexProgram::vertex_data_type> * vertices) : map_function(map_function),
668 finalize_function(finalize_function) {
669 vertexInmemoryArray = vertices;
676 aggr = ReductionType();
677 localaggr.resize(gcontext.execthreads);
684 logstream(
LOG_INFO) <<
"Going to run edge-aggregator finalize." << std::endl;
686 for(
int i=0; i < (int)localaggr.size(); i++) {
687 aggr += localaggr[i];
691 finalize_function(glcontext, aggr);
712 for(
int i=0; i < vertex.num_edges(); i++) {
714 ReductionType mapped = map_function(glcontext, edgeWrapper);
717 localaggr[omp_get_thread_num()] += a;
735 double priority()
const {
return value; }
737 value += other.value;
748 double priority()
const {
return value; }
750 value = std::max(value, other.value);
763 template <
typename GraphLabVertexProgram>
764 std::vector<typename GraphLabVertexProgram::vertex_data_type> *
765 run_graphlab_vertexprogram(std::string base_filename,
int nshards,
int niters,
bool scheduler,
metrics & _m,
766 bool modifies_inedges=
true,
bool modifies_outedges=
true) {
768 GLWrapper wrapperProgram;
770 engine.set_modifies_inedges(modifies_inedges);
771 engine.set_modifies_outedges(modifies_outedges);
772 engine.run(wrapperProgram, niters);
773 return wrapperProgram.vertexInmemoryArray;
776 template <
typename GraphLabVertexProgram,
typename ReductionType,
777 typename EdgeMapType,
778 typename FinalizerType>
779 ReductionType run_graphlab_edge_aggregator(std::string base_filename,
int nshards,
780 EdgeMapType map_function,
781 FinalizerType finalize_function, std::vector<typename GraphLabVertexProgram::vertex_data_type> * vertices,
metrics & _m) {
783 logstream(
LOG_INFO) <<
"Starting edge aggregator." << std::endl;
784 GLEdgeAggrWrapper glAggregator(map_function, finalize_function, vertices);
786 engine.set_modifies_inedges(
false);
787 engine.set_modifies_outedges(
false);
788 engine.run(glAggregator, 1);
789 return glAggregator.aggr;