giraph-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Jake Mannix (Commented) (JIRA)" <>
Subject [jira] [Commented] (GIRAPH-83) Is Vertex correct yet?
Date Tue, 15 Nov 2011 19:03:51 GMT


Jake Mannix commented on GIRAPH-83:

I agree that simplifying this class is a good idea.  Let's look at the specifics you're talking

Basic/Mutable/<nothing>-Vertex.  BasicVertex is essentially an interface, the definition
of what it means to be a Vertex.  I think it should probably actually be *called* Vertex,
because everything "is a" BasicVertex currently, so it makes sense instead to say everything
"is a" Vertex.  At the other end, the class we currently call Vertex is just the generic implementation
of everything you can do assuming you represent the edges and messages as a big Map<I,
E> and List<M>.  If you want a special representation (ie using primitives, or compressed
data structures, or even dynamically/algorithmically defined edge-sets where nothing lives
in memory), you don't want to use this, and derive directly from BasicVertex.  

The only one we could reasonably do away with is MutableVertex, and declare that all Vertex
impls are mutable.  But I'm wary of doing such a thing, as the idea of having a sub-implementation
which simply *does not allow* mutation is a very common use case, and possibly knowing that
you have an immutable graph structure can allow some implementations to do fun and speedy
multithreaded computation (think: some people will run their Giraph jobs with heap sizes large
enough per mapper to take over the whole box they're on, in which case they have lots of CPU
to spare, and probably don't need it *all* for RPC).

Second: What belongs in Vertex itself?  We already moved some global stuff out of Vertex into
GraphState (which should maybe be called "GlobalGraphState"), and we have the WorkerContext
as a separate class, and the Aggregators separate.  

We can factor off lots of stuff into other classes, but the question comes down to how does
the user writing their algorithm get access to them?  How is it all wired together?  You want
compute() to get passed some state that you have right when you need it, instead of either
going with inheritance *or* composition?  That could be nice, I think, as long as we package
it all up into a minimal set of *Context-like objects to carry around.

In what way are the out edges of a vertex "managed by the framework" currently?
> Is Vertex correct yet?
> ----------------------
>                 Key: GIRAPH-83
>                 URL:
>             Project: Giraph
>          Issue Type: Improvement
>            Reporter: Jakob Homan
> I'm seeing a number of people run into oddities with Vertex and am thinking we may not
have it quite correct yet...

This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:!default.jspa
For more information on JIRA, see:


View raw message