private void graph_creator_aux(IInputFormatInstance gif)
{
bool weighted = gif.Weight.Length == gif.Source.Length; float f = 1.0f;
for (int i = 0; i < gif.ESIZE; i++)
{
int s = gif.Source [i];
int t = gif.Target [i];
if (weighted)
{
f = gif.Weight [i];
}
g.addVertex(s);
g.addVertex(t);
g.noSafeAdd(s, t, f);
if (s == 0 || t == 0)
{
throw new ArgumentNullException("WARNING: Vertex id is 0! ");
}
}
IIteratorInstance <IKVPair <IInteger, IInputFormat> > output_gifs_instance = (IIteratorInstance <IKVPair <IInteger, IInputFormat> >)Output_gif.Instance;
IKVPairInstance <IInteger, IInputFormat> item = (IKVPairInstance <IInteger, IInputFormat>)Output_gif.createItem();
((IIntegerInstance)item.Key).Value = gif.PARTID;
item.Value = gif;
output_gifs_instance.put(item);
}
public override void main()
{
Trace.WriteLine(Rank + ": START SPLIT PATH INFO 1");
IIteratorInstance <IPathInfo> input_data_instance = (IIteratorInstance <IPathInfo>)Input_data.Instance;
IIteratorInstance <IKVPair <IInteger, IPathInfo> > output_data_instance = (IIteratorInstance <IKVPair <IInteger, IPathInfo> >)Output_data.Instance;
Trace.WriteLine(Rank + ": START SPLIT PATH INFO 2");
object path_info;
while (input_data_instance.fetch_next(out path_info))
{
Trace.WriteLine(Rank + ": LOOP SPLIT PATH INFO " + path_info.GetType());
IPathInfoInstance path_info_instance = (IPathInfoInstance)path_info;
IKVPairInstance <IInteger, IPathInfo> path_info_output = (IKVPairInstance <IInteger, IPathInfo>)Output_data.createItem();
((IIntegerInstance)path_info_output.Key).Value = ((Info)path_info_instance.Value).vertex;
path_info_output.Value = path_info_instance;
Trace.WriteLine(Rank + ": vertex = " + path_info_output.Key);
output_data_instance.put(path_info_output);
}
output_data_instance.finish();
Trace.Write(Rank + ": STOP SPLIT PATH INFO ");
}
public void gust0()
{
IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value_instance = (IIteratorInstance <IKVPair <IVertex, IDataTriangle> >)Output.Instance;
IEnumerator <int> V = g.vertexSet().GetEnumerator();
while (V.MoveNext())
{
int v = V.Current;
if (!isGhost(v))
{
ICollection <int> vneighbors = g.neighborsOf(v);
foreach (int w in vneighbors)
{
if (v < w) //buscam-se os vérices maiores que v e com partições distintas
{
if (partition[v - 1] != partition[w - 1])
{
IKVPairInstance <IVertex, IDataTriangle> item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
((IVertexInstance)item.Key).Id = w;
((IDataTriangleInstance)item.Value).V = v;
output_value_instance.put(item);
}
}
}
}
}
}
public override void main()
{
IIteratorInstance <IKVPair <IString, ICliqueNode> > output = (IIteratorInstance <IKVPair <IString, ICliqueNode> >)Output_data.Instance;
IIntegerInstance input_key = (IIntegerInstance)Input_key.Instance;
ICliqueNodeInstance input_value = (ICliqueNodeInstance)Input_value.Instance;
//Debug Start
// string saida = "";
// IIntegerInstance I = input_key;
// ICliqueNodeInstance N = input_value;
// saida = "TaskRank="+this.Rank+" <" + I.Value + ", [";
// IEnumerator<int> neighbor = N.NeighborsInstance.GetEnumerator ();
// while (neighbor.MoveNext ()) {
// saida = saida + neighbor.Current + " ";
// }
// saida = saida + "]>";
// using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"./logCliqueMap"+Rank, true)){
// file.WriteLine(saida);
// }
//Debug End
IEnumerator <int> iterator = input_value.NeighborsInstance.GetEnumerator();
while (iterator.MoveNext())
{
IKVPairInstance <IString, ICliqueNode> KV = (IKVPairInstance <IString, ICliqueNode>)Output_data.createItem();
((IStringInstance)KV.Key).Value = iterator.Current.ToString();
((ICliqueNodeInstance)KV.Value).IdInstance = input_value.IdInstance;
((ICliqueNodeInstance)KV.Value).NeighborsInstance = input_value.NeighborsInstance;
output.put(KV);
}
}
public void pull()
{
IKVPairInstance <IVertex, IIterator <IDataTriangle> > input_values_instance = (IKVPairInstance <IVertex, IIterator <IDataTriangle> >)Input_values.Instance;
IVertexInstance ikey = (IVertexInstance)input_values_instance.Key;
IIteratorInstance <IDataTriangle> ivalues = (IIteratorInstance <IDataTriangle>)input_values_instance.Value;
IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value = (IIteratorInstance <IKVPair <IVertex, IDataTriangle> >)Output.Instance;
object o; int w = ikey.Id;
while (ivalues.fetch_next(out o))
{
IEnumerator <int> wneighbors = g.iteratorNeighborsOf(w);
while (wneighbors.MoveNext())
{
int z = wneighbors.Current;
if (w < z)
{
IKVPairInstance <IVertex, IDataTriangle> item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
((IVertexInstance)item.Key).Id = ((IDataTriangleInstance)o).V;
((IDataTriangleInstance)item.Value).V = w;
((IDataTriangleInstance)item.Value).W = z;
output_value.put(item);
}
}
}
}
/* Recebimento de ORVs das unidades source */
public void receiveCombineORVs()
{
int listenFinishedObject = 0;
Trace.WriteLine(WorldComm.Rank + ": START COMBINER TARGET !!!");
object orv;
MPI.CompletedStatus status;
while (listenFinishedObject < size_reducers)
{
Trace.WriteLine(WorldComm.Rank + ": BEGIN RECEIVE COMBINER TARGET to ");
comm.Receive <object>(MPI.Unsafe.MPI_ANY_SOURCE, MPI.Unsafe.MPI_ANY_TAG, out orv, out status);
Trace.WriteLine(WorldComm.Rank + ": END RECEIVE COMBINER TARGET to " + (status.Source));
if (status.Tag == TAG_COMBINER_ORV_FINISH)
{
listenFinishedObject = listenFinishedObject + 1;
}
else
{
combine_input_data_instance.put(orv);
}
}
combine_input_data_instance.finish();
Trace.WriteLine(WorldComm.Rank + ": FINISH COMBINER TARGET !!!");
}
private void emite(int a, int b, int c, IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value)
{
IKVPairInstance <IVertex, IDataTriangle> item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
((IVertexInstance)item.Key).Id = a; //a menor que b
((IDataTriangleInstance)item.Value).V = b; //b menor que c
((IDataTriangleInstance)item.Value).W = c;
output_value.put(item);
}
public void gust0() //emite saídas
{
IIteratorInstance <IKVPair <IInteger, IDataSSSP> > output_value_instance = (IIteratorInstance <IKVPair <IInteger, IDataSSSP> >)Output.Instance;
bool any_emite = false;
foreach (bool any in emite)
{
any_emite = any_emite || any;
}
if (!any_emite && halt_sum == 0)
{
output_value_instance.finish(); // TerminatedFunctionSSSP é avisado com um finish(), preparando-se para a emissão definitiva de saída
IKVPairInstance <IInteger, IDataSSSP> ITEM = (IKVPairInstance <IInteger, IDataSSSP>)Output.createItem();
((IIntegerInstance)ITEM.Key).Value = this.partid;
((IDataSSSPInstance)ITEM.Value).Path_size = messages [((IIntegerInstance)ITEM.Key).Value];
((IDataSSSPInstance)ITEM.Value).Halt = 0;
output_value_instance.put(ITEM);
}
else
{
for (int i = 0; i < partition_size; i++)
{
IKVPairInstance <IInteger, IDataSSSP> ITEM = (IKVPairInstance <IInteger, IDataSSSP>)Output.createItem();
((IIntegerInstance)ITEM.Key).Value = i;
if (partition_own [i] || !emite [i])
{
((IDataSSSPInstance)ITEM.Value).Path_size = new Dictionary <int, float> ();
}
else
{
((IDataSSSPInstance)ITEM.Value).Path_size = messages [i];
}
((IDataSSSPInstance)ITEM.Value).Halt = any_emite ? 1 : 0;
output_value_instance.put(ITEM);
}
}
emite = new bool[partition_size];
halt_sum = 0;
}
public override void main()
{
IStringInstance input = (IStringInstance)Input_value.Instance;
IIteratorInstance <IKVPair <IString, IString> > output = (IIteratorInstance <IKVPair <IString, IString> >)Output_data.Instance;
if (!input.Value.Equals(""))
{
string[] words = input.Value.Split(' ');
IKVPairInstance <IString, IString> kvpair = (IKVPairInstance <IString, IString>)Output_data.createItem();
((IStringInstance)kvpair.Key).Value = words [0];
((IStringInstance)kvpair.Value).Value = words [1] + " " + words [2];
output.put(kvpair);
if (!words [1].Equals("c") && !words [1].Equals("d"))
{
IKVPairInstance <IString, IString> kvpair2 = (IKVPairInstance <IString, IString>)Output_data.createItem();
((IStringInstance)kvpair2.Key).Value = words [1];
((IStringInstance)kvpair2.Value).Value = "i" + " " + words [0];
output.put(kvpair2);
}
}
}
private void emite()
{
IIteratorInstance <IKVPair <IInteger, IDataPGRANK> > output_value_instance = (IIteratorInstance <IKVPair <IInteger, IDataPGRANK> >)Output.Instance;
if (iteration_sum == num_iteration)
{
output_value_instance.finish();
IKVPairInstance <IInteger, IDataPGRANK> ITEM = (IKVPairInstance <IInteger, IDataPGRANK>)Output.createItem();
((IIntegerInstance)ITEM.Key).Value = this.partid;
((IDataPGRANKInstance)ITEM.Value).Ranks = messages [((IIntegerInstance)ITEM.Key).Value];
output_value_instance.put(ITEM);
}
else
{
for (int i = 0; i < partition_size; i++)
{
IKVPairInstance <IInteger, IDataPGRANK> ITEM = (IKVPairInstance <IInteger, IDataPGRANK>)Output.createItem();
((IIntegerInstance)ITEM.Key).Value = i;
if (partition_own [i])
{
((IDataPGRANKInstance)ITEM.Value).Ranks = new Dictionary <int, float> ();
}
else
{
((IDataPGRANKInstance)ITEM.Value).Ranks = messages [i];
messages [i] = new Dictionary <int, float> ();
}
((IDataPGRANKInstance)ITEM.Value).Slice = nothing_outgoing / ((float)partition.Length);
output_value_instance.put(ITEM);
}
}
iteration_sum++;
nothing_outgoing = 0.0f;
sum_nothings = 0.0f;
}
} // Isso é necessário no caso de IKey ser do tipo IVertex.
#endregion
#region Algorithm implementation
public void startup_push()
{
IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value_instance = (IIteratorInstance <IKVPair <IVertex, IDataTriangle> >)Output.Instance;
IEnumerator <int> V = g.vertexSet().GetEnumerator();
while (V.MoveNext())
{
int v = V.Current;
if (!isGhost(v))
{
ICollection <int> vneighbors = g.neighborsOf(v);
foreach (int w in vneighbors)
{
if (v < w) //buscam-se os vérices maiores
{
if (isGhost(w))
{
IKVPairInstance <IVertex, IDataTriangle> item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
IVertexInstance ok = (IVertexInstance)item.Key;
IDataTriangleInstance ov = (IDataTriangleInstance)item.Value;
ok.Id = w;
ov.V = v;
output_value_instance.put(item);
}
else
{
IList <KeyValuePair <int, int> > l;
if (!triangles.TryGetValue(v, out l))
{
l = new List <KeyValuePair <int, int> > ();
triangles[v] = l;
}
IEnumerator <int> wneighbors = g.iteratorNeighborsOf(w);
while (wneighbors.MoveNext())
{
int z = wneighbors.Current;
if (w < z && vneighbors.Contains(z))
{
l.Add(new KeyValuePair <int, int> (w, z));
count++;
}
}
}
}
}
}
}
}
public void pull()
{
IKVPairInstance <IVertex, IIterator <IDataTriangle> > input_values_instance = (IKVPairInstance <IVertex, IIterator <IDataTriangle> >)Input_values.Instance;
IVertexInstance ikey = (IVertexInstance)input_values_instance.Key;
IIteratorInstance <IDataTriangle> ivalues = (IIteratorInstance <IDataTriangle>)input_values_instance.Value;
IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value = (IIteratorInstance <IKVPair <IVertex, IDataTriangle> >)Output.Instance;
object o; int w = ikey.Id;
while (ivalues.fetch_next(out o))
{
int v = ((IDataTriangleInstance)o).V; int z = ((IDataTriangleInstance)o).W;
IEnumerator <int> wneighbors = g.iteratorNeighborsOf(w);
while (wneighbors.MoveNext())
{
int zw = wneighbors.Current;
if (w < zw)
{
if (z == 0)
{
IKVPairInstance <IVertex, IDataTriangle> item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
IVertexInstance ok = (IVertexInstance)item.Key;
IDataTriangleInstance ov = (IDataTriangleInstance)item.Value;
ok.Id = v;
ov.V = w;
ov.W = zw;
output_value.put(item);
}
else
{
IList <KeyValuePair <int, int> > l;
if (!triangles.TryGetValue(w, out l))
{
l = new List <KeyValuePair <int, int> > ();
triangles [w] = l;
}
if (z == zw)
{
l.Add(new KeyValuePair <int, int>(v, zw));
count++;
}
}
}
}
}
}
public override void main()
{
/* 1. Ler pares chave (OMK) e valores (OMV) de Input.
* 2. Para cada par, atribuir a Key e Values e chamar Reduce_function.go();
* 3. Pegar o resultado de Reduction_function.go() de Output_reduce (ORV)
* e colocar no iterator Output.
*/
IIteratorInstance <IKVPair <OMK, IIterator <OMV> > > input_instance = (IIteratorInstance <IKVPair <OMK, IIterator <OMV> > >)Input.Instance;
IIteratorInstance <ORV> output_instance = (IIteratorInstance <ORV>)Output.Instance;
//long t0 = (long)(DateTime.UtcNow - (new DateTime (1970, 1, 1, 0, 0, 0, DateTimeKind.Utc))).TotalMilliseconds;
object kvpair_object;
while (input_instance.fetch_next(out kvpair_object))
{
IKVPairInstance <OMK, IIterator <OMV> > kvpair = (IKVPairInstance <OMK, IIterator <OMV> >)kvpair_object;
Input_reduce.Instance = kvpair;
Reduce_function.go();
active++;
active = active - Reduce_function.Active;
}
string candidates_buffer = sincronize();
while (active > 0)
{
active = 0;
string[] lines = candidates_buffer.Split(new char[] { System.Environment.NewLine[0] });
foreach (string line in lines)
{
if (!line.Trim().Equals(""))
{
string[] values = line.Split(' ');
Reduce_function.step(int.Parse(values[0]), double.Parse(values[1]));
active++;
active = active - Reduce_function.Active;
}
}
candidates_buffer = sincronize();
}
Reduce_function.apply();
output_instance.put(Output_reduce.Instance);
output_instance.finish();
//long t1 = (long)(DateTime.UtcNow - (new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc))).TotalMilliseconds;
//writeFile ("./logTIME-REDUCE", "TIME: " + (t1 - t0) + " ms."+System.Environment.NewLine+"BSP");
}
public override void main()
{
Console.WriteLine("################################*IAplicacaoImpl Start ###############################");
IDoubleInstance tDouble = (IDoubleInstance)T_double.Instance;
IKVPairInstance <IString, IDouble> tKVPair = (IKVPairInstance <IString, IDouble>)T_kvpair.Instance; //.newInstance ();
IIntegerInstance tInteger = (IIntegerInstance)T_integer.Instance;
IIteratorInstance <IInteger> tIterator = (IIteratorInstance <IInteger>)T_iterator.Instance; //.newInstance ();
IStringInstance tString = (IStringInstance)T_string.Instance;
tDouble.Value = 0.8;
tInteger.Value = 8;
tString.Value = "Tipo String";
((IStringInstance)tKVPair.Key).Value = tString.Value;
((IDoubleInstance)tKVPair.Value).Value = tDouble.Value;
tIterator.put(tInteger);
tIterator.finish();
object o; int count = 0;
while (tIterator.fetch_next(out o))
{
IIntegerInstance oI = (IIntegerInstance)o;
Console.WriteLine("Item Iterator " + (count++) + ": " + oI.Value);
}
Console.WriteLine("tDouble.Value=" + tDouble.Value + " : " + "tInteger.Value=" + tInteger.Value + " : " + "tString.Value=" + tString.Value);
Console.WriteLine("tKVPair.Key=" + ((IStringInstance)tKVPair.Key).Value + " : " + "tKVPair.Value=" + ((IDoubleInstance)tKVPair.Value).Value);
IPageNodeInstance instance = (IPageNodeInstance)T_aplicacao_node.Instance;
((IIntegerInstance)instance.IdInstance).Value = 8;
IIntegerInstance item = (IIntegerInstance)T_aplicacao_node.Edge_node.createItem();
item.Value = 7;
instance.NeighborsInstance.put(item);
instance.NeighborsInstance.put(((IIntegerInstance)instance.IdInstance));
instance.NeighborsInstance.finish();
while (instance.NeighborsInstance.fetch_next(out o))
{
IIntegerInstance II = (IIntegerInstance)o;
Console.WriteLine("%%%%%%%%%%%%%%%%%%%%%%%%%%%% Valor no Iterator=" + II.Value);
}
Console.WriteLine("%%%%%%%%%%%%%%%%%%%%%%%%%%%% Resultado Id_node=" + ((IIntegerInstance)instance.IdInstance).Value + " PGRank=" + instance.PgrankInstance.Value);
Console.WriteLine("################################ IAplicacaoImpl End ###############################");
}
public void gust0()
{
IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value_instance = (IIteratorInstance <IKVPair <IVertex, IDataTriangle> >)Output.Instance;
ConcurrentDictionary <int, IList <KeyValuePair <int, int> > > buffer_tmp = new ConcurrentDictionary <int, IList <KeyValuePair <int, int> > >();
IEnumerator <int> next = messages.Keys.GetEnumerator();
while (next.MoveNext())
{
int w = next.Current;
IList <KeyValuePair <int, int> > l;
messages.TryRemove(w, out l);
IEnumerator <int> wneighbors = g.iteratorNeighborsOf(w);
while (wneighbors.MoveNext())
{
int z = wneighbors.Current;
if (w < z)
{
foreach (KeyValuePair <int, int> kvw in l)
{
int v = kvw.Key;
if (isGhost(v))
{
IKVPairInstance <IVertex, IDataTriangle> item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
IVertexInstance ok = (IVertexInstance)item.Key;
IDataTriangleInstance ov = (IDataTriangleInstance)item.Value;
ok.Id = v;
ov.V = z;
ov.W = w;
output_value_instance.put(item);
}
else
{
IList <KeyValuePair <int, int> > lz;
if (!buffer_tmp.TryGetValue(v, out lz))
{
lz = new List <KeyValuePair <int, int> > ();
buffer_tmp[v] = lz;
}
lz.Add(new KeyValuePair <int, int>(z, w));
}
}
}
}
}
messages = buffer_tmp;
}
void feedInitialData(string setE, IIteratorInstance <IPathInfo> initial_data_instance)
{
string[] lines = setE.Split(new char[] { System.Environment.NewLine[0] });
foreach (string line in lines)
{
if (!line.Trim().Equals(""))
{
Trace.WriteLine(Rank + ": LINE = " + line);
string[] edge_info_items = line.Split(' ');
IPathInfoInstance edge = (IPathInfoInstance)Initial_data.createItem();
char item_type = edge_info_items [1] [0];
switch (item_type)
{
case 'c':
DistanceInfo dist_instance_c = new DistanceInfo();
dist_instance_c.info_type = Info.PATH_INFO_TYPE_DISTANCE_TRIAL;
dist_instance_c.vertex = int.Parse(edge_info_items [0]);
dist_instance_c.distance = int.Parse(edge_info_items [2]);
edge.Value = dist_instance_c;
Trace.WriteLine(Rank + ": c " + dist_instance_c.info_type + " " + dist_instance_c.vertex + " " + dist_instance_c.distance);
break;
case 'd':
DistanceInfo dist_instance_d = new DistanceInfo();
dist_instance_d.info_type = Info.PATH_INFO_TYPE_DISTANCE_TRIAL;
dist_instance_d.vertex = int.Parse(edge_info_items [0]);
dist_instance_d.distance = int.Parse(edge_info_items [2]);
edge.Value = dist_instance_d;
Trace.WriteLine(Rank + ": d " + dist_instance_d.info_type + " " + dist_instance_d.vertex + " " + dist_instance_d.distance);
break;
default:
EdgeInfo edge_info = new EdgeInfo();
edge_info.info_type = Info.PATH_INFO_TYPE_EDGE;
edge_info.vertex = int.Parse(edge_info_items[0]);
edge_info.vertex_other = int.Parse(edge_info_items[1]);
edge_info.weight = int.Parse(edge_info_items[2]);
edge.Value = edge_info;
Trace.WriteLine(Rank + ": edge " + edge_info.info_type + " " + edge_info.vertex + " " + edge_info.vertex_other + " " + edge_info.weight);
break;
}
initial_data_instance.put(edge);
}
}
initial_data_instance.finish();
}
} // Isso é necessário no caso de IKey ser do tipo IVertex.
#endregion
#region Algorithm implementation
public void startup_push()
{
// Talvez o startup aqui não seja necessário, desde que o pull da etapa 1 seja alcançado na iteração 2.
// Nesse caso, na (etapa 1).pull(), o código while (ivalues.fetch_next (out o)) { } também não é necessário.
// Para teste de comunicação, este startup envia pares para a etapa 1, confirmando que inputformat chegou aqui com sucesso.
output_ids();
if (!isGhost(1))
{
IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value_instance = (IIteratorInstance <IKVPair <IVertex, IDataTriangle> >)Output.Instance;
foreach (int id in first_ids_found)
{
IKVPairInstance <IVertex, IDataTriangle> item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
((IVertexInstance)item.Key).Id = -id;
output_value_instance.put(item);
}
}
}
public override void main()
{
Trace.WriteLine(Rank + ": MAP FUNCTION IDENTITY #1 " + Output_data.Instance.GetType());
IIteratorInstance <IKVPair <OMK, OMV> > output = (IIteratorInstance <IKVPair <OMK, OMV> >)Output_data.Instance;
object test = Output_data.createItem();
Trace.WriteLine(Rank + ": MAP FUNCTION IDENTITY #3" + test.GetType());
IKVPairInstance <IMK, IMV> kvpair = (IKVPairInstance <IMK, IMV>)Output_data.createItem();
Trace.WriteLine(Rank + ": MAP FUNCTION IDENTITY #4" + " - " + Input_key.Instance.GetType());
kvpair.Key = Input_key.Instance;
kvpair.Value = Input_value.Instance;
output.put(kvpair);
}
public void startup_push()
{
IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value_instance = (IIteratorInstance <IKVPair <IVertex, IDataTriangle> >)Output.Instance;
int v, ordered, i, j;
IEnumerator <int> V = g.vertexSet().GetEnumerator();
while (V.MoveNext())
{
v = V.Current;
if (!isGhost(v))
{
IEnumerator <int> vneighbors = g.iteratorNeighborsOf(v);
while (vneighbors.MoveNext())
{
int bigger = vneighbors.Current;
if (v < bigger) //buscam-se os vérices maiores
{
if (isGhost(bigger))
{
IKVPairInstance <IVertex, IDataTriangle> item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
IVertexInstance ok = (IVertexInstance)item.Key;
IDataTriangleInstance ov = (IDataTriangleInstance)item.Value;
ok.Id = bigger;
ov.V = v;
output_value_instance.put(item);
}
else
{
IList <KeyValuePair <int, int> > l;
if (!messages.TryGetValue(bigger, out l))
{
l = new List <KeyValuePair <int, int> > ();
messages[bigger] = l;
}
l.Add(new KeyValuePair <int, int>(v, 0));
}
}
}
}
}
}
private void graph_creator_aux(IInputFormatInstance gif)
{
for (int i = 0; i < gif.ESIZE;)
{
if (gif.Target [i] != 0) // Será usada a forma canonica: i->j, onde i<j, i>0 j>0
{
int s = gif.Source [i] < gif.Target [i] ? gif.Source [i] : gif.Target [i];
int t = gif.Target [i] > gif.Source [i] ? gif.Target [i] : gif.Source [i];
g.addVertex(s);
g.addVertex(t);
g.noSafeAdd(s, t);
i++;
}
}
IIteratorInstance <IKVPair <IInteger, IInputFormat> > output_gifs_instance = (IIteratorInstance <IKVPair <IInteger, IInputFormat> >)Output_gif.Instance;
IKVPairInstance <IInteger, IInputFormat> item = (IKVPairInstance <IInteger, IInputFormat>)Output_gif.createItem();
((IIntegerInstance)item.Key).Value = gif.PARTID;
item.Value = gif;
output_gifs_instance.put(item); // Emite-se gif novamente para que a funcão de particionamento do conector receba a instancia PartitionTABLE.
} // Isso é necessário no caso de IKey ser do tipo IVertex.
private void readPair_OMK_OMVs()
{
IIteratorInstance <IKVPair <OMK, IIterator <OMV> > > input_instance = (IIteratorInstance <IKVPair <OMK, IIterator <OMV> > >)Input.Instance;
IIteratorInstance <ORV> output_instance = (IIteratorInstance <ORV>)Output.Instance;
object kvpair_object;
int count = 0;
while (input_instance.fetch_next(out kvpair_object))
{
Trace.WriteLine(WorldComm.Rank + ": REDUCER LOOP 1!" + (count++));
IKVPairInstance <OMK, IIterator <OMV> > kvpair = (IKVPairInstance <OMK, IIterator <OMV> >)kvpair_object;
Input_reduce.Instance = kvpair;
Reduce_function.go();
output_instance.put(Output_reduce.Instance);
}
output_instance.finish();
Trace.WriteLine(WorldComm.Rank + ": FINISH REDUCER !!!");
}
private void graph_creator_aux(IInputFormatInstance gif)
{
for (int i = 0; i < gif.ESIZE; i++)
{
int s = gif.Source [i];
int t = gif.Target [i];
g.addVertex(s);
g.addVertex(t);
g.addEdge(s, t);
if (s == 0 || t == 0)
{
throw new ArgumentNullException("WARNING: Vertex id is 0! ");
}
}
IIteratorInstance <IKVPair <IInteger, IInputFormat> > output_gifs_instance = (IIteratorInstance <IKVPair <IInteger, IInputFormat> >)Output_gif.Instance;
IKVPairInstance <IInteger, IInputFormat> item = (IKVPairInstance <IInteger, IInputFormat>)Output_gif.createItem();
((IIntegerInstance)item.Key).Value = gif.PARTID;
item.Value = gif;
output_gifs_instance.put(item);
}
private void graph_creator_aux(IInputFormatInstance gif)
{
for (int i = 0; i < gif.ESIZE;)
{
if (gif.Target [i] != 0) // Será usada a forma canonica: i->j, onde i<j, i>0 j>0
{
int s = gif.Source [i] < gif.Target [i] ? gif.Source [i] : gif.Target [i];
int t = gif.Target [i] > gif.Source [i] ? gif.Target [i] : gif.Source [i];
g.addVertex(s);
g.addVertex(t);
g.noSafeAdd(s, t); //Usando noSafeAdd! Isso significa que erros no arquivo fonte não serão tratados.
i++; //Ou seja, os dados serão inseridos da forma como chegam. Para tratamento, usa-se g.addEdge(s,t).
}
}
IIteratorInstance <IKVPair <IInteger, IInputFormat> > output_gifs_instance = (IIteratorInstance <IKVPair <IInteger, IInputFormat> >)Output_gif.Instance;
IKVPairInstance <IInteger, IInputFormat> item = (IKVPairInstance <IInteger, IInputFormat>)Output_gif.createItem();
((IIntegerInstance)item.Key).Value = gif.PARTID;
item.Value = gif;
output_gifs_instance.put(item); // Emite-se gif novamente para que a funcão de particionamento do conector receba a instancia PartitionTABLE.
} // Isso é necessário no caso de IKey ser do tipo IVertex.
public override void main()
{
IStringInstance input_value_instance = (IStringInstance)Input_value.Instance;
IIteratorInstance <IKVPair <IString, IInteger> > output_value_instance = (IIteratorInstance <IKVPair <IString, IInteger> >)Output_data.Instance;
string input_string = input_value_instance.Value;
string chars = " ;?.!:,*<>+";
string[] words = input_string.Split(new char[] { chars[0], chars[1], chars[2], chars[3], chars[4], chars[5], chars[6], chars[7], chars[8], chars[9], chars[10] });
IDictionary <string, int> index = new Dictionary <string, int>();
foreach (string word_ in words)
{
string word = word_.ToLower().Trim();
if (word != "")
{
int counter;
if (index.TryGetValue(word, out counter))
{
index.Remove(word);
}
else
{
counter = 0;
}
index.Add(word, counter + 1);
}
}
foreach (KeyValuePair <string, int> occurrences in index)
{
// Trace.WriteLine(WorldComm.Rank + ": MAP (WORD COUNTER) - " + occurrences.Key + ":" + occurrences.Value);
IKVPairInstance <IString, IInteger> item = (IKVPairInstance <IString, IInteger>)Output_data.createItem();
((IStringInstance)item.Key).Value = occurrences.Key;
((IIntegerInstance)item.Value).Value = occurrences.Value;
output_value_instance.put(item);
}
}
public override void main()
{
IIteratorInstance <ORV> input_data_instance = (IIteratorInstance <ORV>)Input_data.Instance;
IIteratorInstance <ORV> output_data_instance = (IIteratorInstance <ORV>)Output_data.Instance;
Trace.WriteLine(WorldComm.Rank + ": START COMBINE FUNCTION !!! ");
object item_object;
int count = 0;
while (input_data_instance.fetch_next(out item_object))
{
Trace.WriteLine(WorldComm.Rank + ": COMBINE_FUNCTION_LOOP 1 " + (count++) + " " + item_object.GetType());
output_data_instance.put(item_object);
}
Trace.WriteLine(WorldComm.Rank + ": OUT LOOP COMBINE FUNCTION !!!");
output_data_instance.finish();
Trace.WriteLine(WorldComm.Rank + ": FINISH COMBINE FUNCTION !!!");
}
public override void main()
{
Console.WriteLine(this.Rank + ": TERMINATE FUNCTION 1");
IIteratorInstance <IKVPair <OKey, OValue> > output_pairs = (IIteratorInstance <IKVPair <OKey, OValue> >)Output_pairs.Instance;
IIteratorInstance <IKVPair <IKey, IValue> > input_pairs = (IIteratorInstance <IKVPair <IKey, IValue> >)Input_pairs.Instance;
Console.WriteLine(this.Rank + ": TERMINATE FUNCTION 2");
input_pairs.finish();
// All pairs are sent to the output, i.e. the algorithm is not iterative.
object pair;
while (iterate_pairs.fetch_next(out pair))
{
output_pairs.put(pair);
}
output_pairs.finish();
Console.WriteLine(this.Rank + ": TERMINATE FUNCTION 3");
}
public override void main()
{
int count = 0;
// 1. recebe os bins enviados pelo gerente (unidade source),
// através do MPI, e os insere no Target_data.
Trace.WriteLine(WorldComm.Rank + ": STARTING SCATTER SPLIT DATA TARGET");
MPI.CompletedStatus status;
int source_rank = this.UnitRanks["source"][0];
object bin_key;
object bin_value;
IIteratorInstance <IKVPair <IMK, IMV> > target_data_instance = (IIteratorInstance <IKVPair <IMK, IMV> >)Target_data.Instance;
Trace.WriteLine(WorldComm.Rank + ": BEGIN RECEIVE BIN KEY from " + source_rank + "count=" + (count++));
comm.Receive <object> (source_rank, MPI.Unsafe.MPI_ANY_TAG, out bin_key, out status);
Trace.WriteLine(WorldComm.Rank + ": END RECEIVE BIN KEY from " + source_rank);
while (status.Tag != TAG_SPLITTER_IMK_FINISH)
{
Trace.WriteLine(WorldComm.Rank + ": BEGIN RECEIVE BIN VALUE from " + source_rank);
comm.Receive <object> (source_rank, TAG_SPLITTER_IMV, out bin_value, out status);
Trace.WriteLine(WorldComm.Rank + ": END RECEIVE BIN VALUE from " + source_rank);
IKVPairInstance <IMK, IMV> pair = (IKVPairInstance <IMK, IMV>)Target_data.createItem();
pair.Key = bin_key;
pair.Value = bin_value;
target_data_instance.put(pair);
Trace.WriteLine(WorldComm.Rank + ": BEGIN RECEIVE BIN KEY from " + source_rank + "count=" + (count++));
comm.Receive <object> (source_rank, MPI.Unsafe.MPI_ANY_TAG, out bin_key, out status);
Trace.WriteLine(WorldComm.Rank + ": END RECEIVE BIN KEY from " + source_rank);
}
Trace.WriteLine(WorldComm.Rank + ": FINISH ALL BIN KEYs #1 !!!");
target_data_instance.finish();
Trace.WriteLine(WorldComm.Rank + ": FINISH ALL BIN KEYs #2 !!!");
}
public void gust1()
{
IIteratorInstance <IKVPair <IVertex, IDataTriangle> > output_value_instance = (IIteratorInstance <IKVPair <IVertex, IDataTriangle> >)Output.Instance;
IKVPairInstance <IVertex, IDataTriangle> item;
IEnumerator <int> next = messages.Keys.GetEnumerator();
while (next.MoveNext())
{
int v = next.Current;
IList <KeyValuePair <int, int> > l;
messages.TryRemove(v, out l);
ICollection <int> vneighbors = g.neighborsOf(v); // devolve ISet<int>, de modo que Contains() é O(1)
foreach (KeyValuePair <int, int> kv in l)
{
int z = kv.Key;
int w = kv.Value;
if (vneighbors.Contains(z)) //Se z é vizinho de v, forma-se um triangulo
// Descomentar para imprimir todos os triangulos
// item = (IKVPairInstance<IVertex,IDataTriangle>)Output.createItem ();
// ((IVertexInstance)item.Key).Id = v; //v menor que w
// ((IDataTriangleInstance)item.Value).V = w; //w menor que z
// ((IDataTriangleInstance)item.Value).W = z;
// output_value_instance.put (item);
{
count++;
}
}
}
item = (IKVPairInstance <IVertex, IDataTriangle>)Output.createItem();
((IVertexInstance)item.Key).Id = count;
//IDataTriangleInstance dt = ((IDataTriangleInstance)item.Value);
//item.Value = dt;
output_value_instance.put(item);
}
//CONFIG
public void readSource()
{
Console.WriteLine(this.GlobalRank + ": STARTING SPLITTER READSOURCE...1");
output_instance_gifs = (IIteratorInstance <IKVPair <IInteger, IIterator <GIF> > >)Output_gifs.Instance;
Feed_graph.Server = output_instance_gifs;
Console.WriteLine(this.GlobalRank + ": STARTING SPLITTER READSOURCE...2");
// RECEIVE PAIR FROM THE SOURCE (1st iteration)
Tuple <int, int> unit_ref_source = new Tuple <int, int> (this.FacetIndexes [FACET_SOURCE] [0], 0);
// Thread[] threads_receive = new Thread[senders_size];
// for (int i = 0; i < senders_size; i++)
// {
// threads_receive [i] = new Thread ((ParameterizedThreadStart)delegate(object unit_ref_obj) {
// Tuple<int,int> unit_ref_i = (Tuple<int,int>)unit_ref_obj;
// receive_pairs_iteration (unit_ref_i);
// });
// }
// TODO: READ_SOURCE é necessário ? Não no map feeder. Tirar fatia de Task_binding data ...
Task_binding_data.TraceFlag = true;
Task_binding_data.invoke(ITaskPortData.READ_SOURCE);
// Do nothing ...
IList <IKVPairInstance <IInteger, GIF> > buffer;
object buffer_obj;
CompletedStatus status;
do
{
IActionFuture sync_perform;
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER - BEFORE READ_CHUNK");
Task_binding_split_first.invoke(ITaskPortAdvance.READ_CHUNK); //****
Task_binding_split_first.invoke(ITaskPortAdvance.PERFORM, out sync_perform);
IDictionary <object, IIteratorInstance <GIF> > kv_cache = new Dictionary <object, IIteratorInstance <GIF> > ();
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER !!! PERFORM OK !");
Split_channel.Receive(unit_ref_source, MPI.Communicator.anyTag, out buffer, out status);
Console.WriteLine(this.Rank + ": CHUNK PAIRS RECEIVED !!! from source buffer.Count=" + buffer.Count);
//foreach (IKVPairInstance<IInteger,GIF> kv in buffer)
// output_instance_gif.put (kv);
foreach (IKVPairInstance <IInteger, GIF> kv in buffer)
{
IIteratorInstance <GIF> iterator = null;
if (!kv_cache.ContainsKey(kv.Key))
{
iterator = Value_factory_gif.newIteratorInstance();
kv_cache.Add(kv.Key, iterator);
IKVPairInstance <IInteger, IIterator <GIF> > item = (IKVPairInstance <IInteger, IIterator <GIF> >)Output_gifs.createItem();
item.Key = kv.Key;
item.Value = iterator;
output_instance_gifs.put(item);
}
else
{
kv_cache.TryGetValue(kv.Key, out iterator);
}
iterator.put(kv.Value);
}
output_instance_gifs.finish();
foreach (IIteratorInstance <IValue> iterator in kv_cache.Values)
{
iterator.finish();
}
sync_perform.wait();
// CHUNK_READY
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER 1");
Task_binding_split_first.invoke(ITaskPortAdvance.CHUNK_READY);
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER 2");
} while (status.Tag != TAG_SPLIT_END_CHUNK);
output_instance_gifs.finish();
Console.WriteLine(this.Rank + ": FINISH READING CHUNKS OF SOURCE");
}
public void iterate()
{
IList <IKVPairInstance <IKey, IValue> > buffer;
object buffer_obj;
CompletedStatus status;
Console.WriteLine(this.GlobalRank + ": STARTING SPLITTER ITERATE...1");
output_instance = (IIteratorInstance <IKVPair <IKey, IIterator <IValue> > >)Output.Instance;
Feed_pairs.Server = output_instance;
Console.WriteLine(this.GlobalRank + ": STARTING SPLITTER ITERATE...2");
IDictionary <int, Tuple <int, int> > unit_ref = new Dictionary <int, Tuple <int, int> > ();
Console.WriteLine(this.GlobalRank + ": STARTING SPLITTER ...3");
// RECEIVE PAIRS FROM THE REDUCERS (next iterations)
int senders_size = 0;
foreach (int i in this.FacetIndexes[FACET_REDUCE])
{
Console.WriteLine(this.GlobalRank + ": STARTING SPLITTER ...4 -- i=" + i);
int nr0 = senders_size;
senders_size += this.UnitSizeInFacet [i] ["gusty_collector"];
for (int k = 0, j = nr0; j < senders_size; k++, j++)
{
unit_ref [j] = new Tuple <int, int> (i, k);
}
}
bool end_computation = false;
while (!end_computation)
{
end_computation = true;
int count_finished_streams = 0;
while (count_finished_streams < senders_size)
{
IActionFuture sync_perform;
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER NEXT 1");
Task_binding_split_next.invoke(ITaskPortAdvance.READ_CHUNK);
Task_binding_split_next.invoke(ITaskPortAdvance.PERFORM, out sync_perform);
IDictionary <object, IIteratorInstance <IValue> > kv_cache = new Dictionary <object, IIteratorInstance <IValue> > ();
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER NEXT 2");
for (int i = 0; i < senders_size; i++)
{
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER NEXT LOOP - before receive");
Split_channel.Receive(unit_ref [i], MPI.Communicator.anyTag, out buffer_obj, out status);
Console.WriteLine(this.Rank + ": CHUNK PAIRS RECEIVED !!! from gusty_collector of index " + i + " / count_finished_streams=" + count_finished_streams);
if (status.Tag == TAG_SPLIT_END_CHUNK)
{
count_finished_streams++;
}
else
{
end_computation = false;
}
try {
buffer = (IList <IKVPairInstance <IKey, IValue> >)buffer_obj;
//foreach (IKVPairInstance<IKey,IValue> kv in buffer)
// output_instance.put (kv);
foreach (IKVPairInstance <IKey, IValue> kv in buffer)
{
IIteratorInstance <IValue> iterator = null;
if (!kv_cache.ContainsKey(kv.Key))
{
iterator = Value_factory.newIteratorInstance();
kv_cache.Add(kv.Key, iterator);
IKVPairInstance <IKey, IIterator <IValue> > item = (IKVPairInstance <IKey, IIterator <IValue> >)Output.createItem();
item.Key = kv.Key;
item.Value = iterator;
output_instance.put(item);
}
else
{
kv_cache.TryGetValue(kv.Key, out iterator);
}
iterator.put(kv.Value);
}
} catch (InvalidCastException e) {
Console.WriteLine("SPLITTER MAPPER: incompatible input !");
count_finished_streams++;
}
}
output_instance.finish();
foreach (IIteratorInstance <IValue> iterator in kv_cache.Values)
{
iterator.finish();
}
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER NEXT 3");
sync_perform.wait();
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER NEXT 4");
// CHUNK_READY
Task_binding_split_next.invoke(ITaskPortAdvance.CHUNK_READY);
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER NEXT 5");
}
}
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER FINISH 1 !");
Task_binding_data.invoke(ITaskPortData.TERMINATE);
Task_binding_data.invoke(ITaskPortData.WRITE_SINK);
Console.WriteLine(this.Rank + ": SPLITTER MAP FEEDER FINISH 2 !");
}
