Try to create a graph that for each accessed vertex, a parallel thread reads 
the neighbor edges and "touches" the opposite vertices so that it is already in 
cache in case it needs to be accessed.

1. Develop an I/O interface in order to read and write a graph from/to a file.
2. Create tool to generate a random graph (possible uses: generate huge graphs 
for performance testing)

Exception handling would be a powerful feature in the library to control the 
*correctness of the graph* where one would want to apply 

Some ideas to work on are:
 1) prefetching mechanisms working in parallel with memory accesses to graph structure
 2) alongside with the prefetching mechanism (or maybe first than that), it would be interesting to implement an iterator, where one of the functionalities could be precisely prefetching possible future needed data

A new complexity arises for generating random graphs: random graph clusters.

Create a graph with several dense areas (with higher connection rate). The 
easier solution thought of so far is: create X independent graphs and then 
connect the all. The connection ratio between clusters (dense areas) must also 
be taken into account.

According to "The generic graph component library" paper, the visitor and 
decorator concepts are used in creating generic iterators ("Lifting sequential 
graph algorithms for distributed-memory parallel computation").

Using indexed array based structures might improve locality since it is 
(preferably) not pointer-chasing. 

Trying out some new structures with this.

NOTE: using explicit arrays instead of more general array implementations (like 
ArrayList in Java) might prove to set the performance back

What steps will reproduce the problem?
1. Generic classes
2. Types suitable and comparable in graphs (int, char, string, etc.)
3. "Refactor" classes and algorithm implementations in order to support generic 
datatype classes (Difficulty: High).

What is the expected output? What do you see instead?
A graph library that supports several datatypes in all the nodes of a graph.

Testing the classes and algorithms with JUnits would be useful for MST result 
correctness testing when the project gains considerable size.