public void graph_creator()
{
IKVPairInstance <IInteger, IIterator <IInputFormat> > input_gifs_instance = (IKVPairInstance <IInteger, IIterator <IInputFormat> >)Graph_values.Instance;
IIteratorInstance <IInputFormat> vgifs = (IIteratorInstance <IInputFormat>)input_gifs_instance.Value;
object o;
if (partition_own == null)
{
if (vgifs.fetch_next(out o))
{
IInputFormatInstance gif = (IInputFormatInstance)o;
partition = gif.PartitionTABLE;
partition_size = gif.PARTITION_SIZE;
g = Graph.newInstance(gif.VSIZE);
g.DataContainer.AllowingLoops = false;
g.DataContainer.AllowingMultipleEdges = false;
graph_creator_aux(gif);
partition_own = new bool[partition_size];
partition_own [gif.PARTID] = true;
this.partid = gif.PARTID;
}
}
while (vgifs.fetch_next(out o))
{
graph_creator_aux((IInputFormatInstance)o);
partition_own [((IInputFormatInstance)o).PARTID] = true;
}
}
public void graph_creator()
{
IKVPairInstance <IInteger, IIterator <IInputFormat> > input_gifs_instance = (IKVPairInstance <IInteger, IIterator <IInputFormat> >)Graph_values.Instance;
IIteratorInstance <IInputFormat> vgifs = (IIteratorInstance <IInputFormat>)input_gifs_instance.Value;
object o;
if (partition_own == null)
{
if (vgifs.fetch_next(out o))
{
IInputFormatInstance gif = (IInputFormatInstance)o;
partition = gif.PartitionTABLE;
partid = gif.PARTID;
partition_size = gif.PARTITION_SIZE;
g = Graph.newInstance(gif.VSIZE); // pega-se uma instancia do graph, com vertices do tipo inteiro, com tamanho previsto VSIZE
g.DataContainer.AllowingLoops = false; // não serão premitidos laços
g.DataContainer.AllowingMultipleEdges = false; // não serão permitidas múltiplas arestas
graph_creator_aux(gif); // inserem-se dados no grafo
partition_own = new bool[partition_size];
partition_own [partid] = true;
}
}
while (vgifs.fetch_next(out o))
{
graph_creator_aux((IInputFormatInstance)o);
partition_own [((IInputFormatInstance)o).PARTID] = true;
}
}
public override void main()
{
IIteratorInstance <IKVPair <IMK, IMV> > input_instance = (IIteratorInstance <IKVPair <IMK, IMV> >)Input.Instance;
IIteratorInstance <IKVPair <OMK, OMV> > output_instance = (IIteratorInstance <IKVPair <OMK, OMV> >)Output.Instance;
object bin_object = null;
int count = 0;
while (input_instance.fetch_next(out bin_object))
{
Trace.WriteLine(Rank + ": LOOP MAPPER !!!" + (count++));
IKVPairInstance <IMK, IMV> bin = (IKVPairInstance <IMK, IMV>)bin_object;
Trace.WriteLine(Rank + ": " + (Map_value.Instance == null) + " $$$$ " + bin.Value.GetType());
Map_key.Instance = bin.Key;
Map_value.Instance = bin.Value;
Map_function.go();
}
Trace.WriteLine(Rank + ": FINISH MAPPER !!!");
output_instance.finish();
}
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);
}
}
}
}
public override void main()
{
Trace.WriteLine(Rank + ": START COMBINE FUNCTION #1");
IIteratorInstance <ORV> input_data_instance = (IIteratorInstance <ORV>)Input_data.Instance;
IKVPairInstance <IInteger, IIterator <IPathInfo> > output_data_instance = (IKVPairInstance <IInteger, IIterator <IPathInfo> >)Output_data.Instance;
Trace.WriteLine(Rank + ": START COMBINE FUNCTION #2");
IIntegerInstance done_flag = (IIntegerInstance)output_data_instance.Key;
IIteratorInstance <IPathInfo> output_distances = (IIteratorInstance <IPathInfo>)output_data_instance.Value;
Trace.WriteLine(Rank + ": START COMBINE FUNCTION #3");
bool done = true;
object o;
while (input_data_instance.fetch_next(out o))
{
IKVPairInstance <IInteger, IIterator <IPathInfo> > kv = (IKVPairInstance <IInteger, IIterator <IPathInfo> >)o;
IIntegerInstance k = (IIntegerInstance)kv.Key;
Trace.WriteLine(Rank + ": LOOP #1 COMBINE FUNCTION " + k.Value);
output_distances.putAll((IIteratorInstance <IPathInfo>)kv.Value);
done = done && k.Value == 1;
}
output_distances.finish();
done_flag.Value = done ? 1 : 0;
Trace.WriteLine(Rank + ": END COMBINE FUNCTION " + done);
}
public override void main()
{
string[] string_iteracoes = readInput("/home/hpe/iteracoes").Split(new char[] { System.Environment.NewLine[0] });
int iteracoes = int.Parse(string_iteracoes [0]);
IStringInstance input_data_instance = (IStringInstance)Input_data.Instance;
IIteratorInstance <IKVPair <IString, IDouble> > output_data_instance = (IIteratorInstance <IKVPair <IString, IDouble> >)Output_data.Instance;
int count = 0;
while (count++ < iteracoes)
{
double X = 0.0;
this.Page_rank.go();
object o;
string saida = "";
while (output_data_instance.fetch_next(out o))
{
IKVPairInstance <IString, IDouble> kvp = (IKVPairInstance <IString, IDouble>)o;
IStringInstance k = (IStringInstance)kvp.Key;
IDoubleInstance v = (IDoubleInstance)kvp.Value;
if (!k.Value.Equals("X"))
{
saida = saida + k.Value + " " + v.Value + System.Environment.NewLine;
}
else
{
X = v.Value;
}
}
input_data_instance.Value = "X " + X + System.Environment.NewLine + saida;
System.Console.WriteLine("PAGERANK ITERATION: " + count + " X:" + X);
}
}
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 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 v = ikey.Id;
ICollection <int> vneighbors = g.neighborsOf(v);
while (ivalues.fetch_next(out o))
{
int w = ((IDataTriangleInstance)o).V;
int z = ((IDataTriangleInstance)o).W;
if (vneighbors.Contains(z) && v < z)
{
IList <KeyValuePair <int, int> > l;
if (!triangles.TryGetValue(v, out l))
{
l = new List <KeyValuePair <int, int> > ();
triangles[v] = l;
}
l.Add(new KeyValuePair <int, int> (w, z));
count++;
//emite (v, w, z, output_value);
}
}
}
public void putAll(IIteratorInstance <T> items)
{
object item;
while (items.fetch_next(out item))
{
put(item);
}
}
public void pull()
{
IKVPairInstance <IVertex, IIterator <IDataTriangle> > input_values_instance = (IKVPairInstance <IVertex, IIterator <IDataTriangle> >)Input_values.Instance;
IIteratorInstance <IDataTriangle> ivalues = (IIteratorInstance <IDataTriangle>)input_values_instance.Value;
object o;
//Sendo a etapa 1, o algoritmo começa no gust0()!
//Porém, descarta-se mensagens de sinalização, emitidas no startup_push da etapa 3 (TC3Impl), o que confirma que InputFormat chegou com sucesso naquela etapa
while (ivalues.fetch_next(out o))
{
}
}
public void read_send_graph(int gusty_size, IDictionary <int, Tuple <int, int> > unit_ref)
{
IIteratorInstance <IKVPair <IInteger, GIF> > input_instance_graph = (IIteratorInstance <IKVPair <IInteger, GIF> >)Collect_graph.Client;
object bin_object = null;
IActionFuture sync_perform;
Partition_function_gif.NumberOfPartitions = gusty_size;
bool end_iteration_gif = false; bool set_table = true;
while (!end_iteration_gif)
{
Task_binding_shuffle.invoke(ITaskPortAdvance.READ_CHUNK);
Task_binding_shuffle.invoke(ITaskPortAdvance.PERFORM, out sync_perform);
IList <IKVPairInstance <IInteger, GIF> >[] buffer_gif = new IList <IKVPairInstance <IInteger, GIF> > [gusty_size];
for (int i = 0; i < gusty_size; i++)
{
buffer_gif [i] = new List <IKVPairInstance <IInteger, GIF> > ();
}
IKVPairInstance <IInteger, GIF> item = null;
if (!input_instance_graph.has_next())
{
end_iteration_gif = true;
}
int count = 0;
while (input_instance_graph.fetch_next(out bin_object))
{
item = (IKVPairInstance <IInteger, GIF>)bin_object;
this.Input_key_gif.Instance = item.Value; //item.Key;
Partition_function_gif.go();
int index = ((IIntegerInstance)this.Output_key_gif.Instance).Value;
buffer_gif [index].Add(item);
Console.WriteLine(this.GlobalRank + ": SHUFFLER MAP Collector Graph count=" + (count++));
}
// PERFORM
for (int i = 0; i < gusty_size; i++)
{
Step_channel.Send(buffer_gif [i], unit_ref [i], end_iteration_gif ? TAG_SHUFFLE_OMV_END_CHUNK : TAG_SHUFFLE_OMV_NEW_CHUNK);
}
sync_perform.wait();
Task_binding_shuffle.invoke(ITaskPortAdvance.CHUNK_READY);
}
Partition_function.PartitionTABLE = Partition_function_gif.PartitionTABLE;
}
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 ###############################");
}
private void clear_gif_set_PartitionTABLE()
{
//Task_binding_split_next.invoke (ITaskPortAdvance.READ_CHUNK); Task_binding_split_next.invoke (ITaskPortAdvance.PERFORM, out sync_perform);
object bin_object = null;
IIteratorInstance <IKVPair <IInteger, GIF> > input_graph_instance = (IIteratorInstance <IKVPair <IInteger, GIF> >)Collect_graph.Client;
while (input_graph_instance.fetch_next(out bin_object))
{
IKVPairInstance <IInteger, GIF> item = (IKVPairInstance <IInteger, GIF>)bin_object;
this.Input_key_iterate_gif.Instance = item.Value;
Bin_function_iterate_gif.go();
((IInputFormatInstance)item.Value).Clear(); //int index = ((IIntegerInstance)this.Output_key_iterate_gif.Instance).Value;
}
Bin_function_iterate.PartitionTABLE = Bin_function_iterate_gif.PartitionTABLE;
//sync_perform.wait ();
}
public override void main()
{
Trace.WriteLine(Rank + ": PARTITIONER (FETCH VALUES SOURCE) - START ");
/* 1. Ler os elementos de Source_data, um a um, e copiar a chave (OMK) em Data_key.
* 2. A cada chave de Source_data, chamar Partition_function.go();
* 3. Enviar o resultado de Partition_function.go(), via MPI, para o gerente (unidade target).
*/
int[] reducer_ranks = this.UnitRanks["reducer"];
int nr = this.UnitSize["reducer"];
Partition_function.NumberOfPartitions = nr;
IIteratorInstance <IKVPair <OMK, OMV> > map_result_instance = (IIteratorInstance <IKVPair <OMK, OMV> >)Map_result.Instance;
int count = 0;
IKVPairInstance <OMK, OMV> last_item = null;
object item_object;
// 1. Ler os elementos de Source_data, um a um, e copiar a chave (OMK) em Data_key.
while (map_result_instance.fetch_next(out item_object))
{
IKVPairInstance <OMK, OMV> item = (IKVPairInstance <OMK, OMV>)item_object;
last_item = item;
Data_key.Instance = item.Key;
// 2. A cada chave de Source_data, chamar Partition_function.go();
Partition_function.go();
int i = (int)((IIntegerInstance)Partition_key.Instance).Value;
Trace.WriteLine(Rank + ": PARTITIONER (FETCH VALUES SOURCE) LOOP - SEND TO " + reducer_ranks[i] + ", source rank is " + comm.Rank + ", count=" + (count++) + "i=" + i);
comm.Send <IKVPairInstance <OMK, OMV> >(item, reducer_ranks[i], TAG_FETCHVALUES_OMV);
}
for (int i = 0; i < nr; i++)
{
comm.Send <IKVPairInstance <OMK, OMV> >(last_item, reducer_ranks[i], TAG_FETCHVALUES_OMV_FINISH);
}
Trace.WriteLine(Rank + ": PARTITIONER (FETCH VALUES SOURCE) - FINISH ");
}
public void pull()
{
IKVPairInstance <IInteger, IIterator <IDataPGRANK> > input_values_instance = (IKVPairInstance <IInteger, IIterator <IDataPGRANK> >)Input_values.Instance;
IIntegerInstance ikey = (IIntegerInstance)input_values_instance.Key;
IIteratorInstance <IDataPGRANK> ivalues = (IIteratorInstance <IDataPGRANK>)input_values_instance.Value;
object o;
while (ivalues.fetch_next(out o))
{
IDataPGRANKInstance VALUE = (IDataPGRANKInstance)o;
foreach (KeyValuePair <int, float> kv in VALUE.Ranks)
{
messages [partition [kv.Key - 1]] [kv.Key] += kv.Value;
}
sum_nothings += VALUE.Slice;
}
}
public override void main()
{
IKVPairInstance <IString, IIterator <IInteger> > input_values_instance = (IKVPairInstance <IString, IIterator <IInteger> >)Input_values.Instance;
IIteratorInstance <IInteger> counts_iterator = (IIteratorInstance <IInteger>)input_values_instance.Value;
int total_count = 0;
object integer_object;
while (counts_iterator.fetch_next(out integer_object))
{
total_count += ((IIntegerInstance)integer_object).Value;
}
IKVPairInstance <IString, IInteger> output_value_instance = (IKVPairInstance <IString, IInteger>)Output_value.newInstance();
((IStringInstance)output_value_instance.Key).Value = ((IStringInstance)input_values_instance.Key).Value;
((IIntegerInstance)output_value_instance.Value).Value = total_count;
// Trace.WriteLine ("TALLIER string=" + ((IStringInstance)output_value_instance.Key).Value + "; count=" + ((IIntegerInstance)output_value_instance.Value).Value);
}
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;
object o;
while (ivalues.fetch_next(out o))
{
IList <KeyValuePair <int, int> > l;
if (!messages.TryGetValue(ikey.Id, out l))
{
l = new List <KeyValuePair <int, int> > ();
messages[ikey.Id] = l;
}
l.Add(new KeyValuePair <int, int>(((IDataTriangleInstance)o).V, ((IDataTriangleInstance)o).W));
}
}
public void pull()
{
IKVPairInstance <IInteger, IIterator <IDataSSSP> > input_values_instance = (IKVPairInstance <IInteger, IIterator <IDataSSSP> >)Input_values.Instance;
IIntegerInstance ikey = (IIntegerInstance)input_values_instance.Key;
IIteratorInstance <IDataSSSP> ivalues = (IIteratorInstance <IDataSSSP>)input_values_instance.Value;
object o; float distance_min;
while (ivalues.fetch_next(out o))
{
IDataSSSPInstance VALUE = (IDataSSSPInstance)o;
halt_sum += VALUE.Halt;
foreach (KeyValuePair <int, float> kv in VALUE.Path_size)
{
int v = kv.Key; float v_distance_min_candidate = kv.Value;
Queue <int> queue = new Queue <int> ();
if (!messages [partition [v - 1]].TryGetValue(v, out distance_min) || distance_min > v_distance_min_candidate)
{
messages [partition [v - 1]] [v] = v_distance_min_candidate;
queue.Enqueue(v);
while (queue.Count > 0) // Busca em profundidade
{
v = queue.Dequeue();
v_distance_min_candidate = messages [partition [v - 1]] [v];
IEnumerator <KeyValuePair <int, float> > vneighbors = g.iteratorVertexWeightOf(v); //g.iteratorOutgoingVertexWeightOf (v);
while (vneighbors.MoveNext())
{
int n = vneighbors.Current.Key;
float n_distance_min_candidate = vneighbors.Current.Value + v_distance_min_candidate;
if (!messages [partition [n - 1]].TryGetValue(n, out distance_min) || distance_min > n_distance_min_candidate)
{
messages [partition [n - 1]] [n] = n_distance_min_candidate;
queue.Enqueue(n);
emite [partition [n - 1]] = true;
}
}
}
}
}
}
}
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 !!!");
}
public override void main()
{
IIteratorInstance <ORV> input_data_instance = (IIteratorInstance <ORV>)Input_data.Instance;
IStringInstance output_data_instance = (IStringInstance)Output_data.Instance;
string setV = "";
bool done = true;
object o;
while (input_data_instance.fetch_next(out o))
{
IKVPairInstance <IString, IString> kv = (IKVPairInstance <IString, IString>)o;
IStringInstance k = (IStringInstance)kv.Key;
IStringInstance v = (IStringInstance)kv.Value;
Trace.WriteLine(Rank + ": COMBINE FUNCTION - done:" + k.Value + " {" + System.Environment.NewLine + v.Value + "}");
setV = setV + v.Value; // + System.Environment.NewLine;
done = done && k.Value.Equals("1");
}
output_data_instance.Value = setV + done;
}
public override void main()
{
((IStringInstance)Input_data.Instance).Value = readInput();
IIteratorInstance <IKVPair <IString, IInteger> > output_data_instance = (IIteratorInstance <IKVPair <IString, IInteger> >)Output_data.Instance;
//Trace.WriteLine ("APP BEFORE GO !!!");
Count_words.go();
//Trace.WriteLine ("APP AFTER GO !!!");
SortedDictionary <int, IList <string> > result_pairs = new SortedDictionary <int, IList <string> >();
int count = 0;
object word_object;
while (output_data_instance.fetch_next(out word_object))
{
IKVPairInstance <IString, IInteger> word = (IKVPairInstance <IString, IInteger>)word_object;
int value = ((IIntegerInstance)word.Value).Value;
string key = ((IStringInstance)word.Key).Value;
IList <string> list_words;
if (!result_pairs.TryGetValue(value, out list_words))
{
list_words = new List <string>();
result_pairs.Add(value, list_words);
}
list_words.Add(key);
}
foreach (int count_word in result_pairs.Keys)
{
foreach (string word in result_pairs[count_word])
{
Trace.WriteLine("RESULT - " + count_word + " : " + word);
}
}
// Trace.WriteLine ("APP FINISH !!! " + count);
}
public override void main()
{
IKVPairInstance <IString, IIterator <IDouble> > input = (IKVPairInstance <IString, IIterator <IDouble> >)Input_values.Instance;
IIteratorInstance <IDouble> doubles = (IIteratorInstance <IDouble>)input.Value;
double soma = 0.0;
object o;
while (doubles.fetch_next(out o))
{
soma += ((IDoubleInstance)o).Value;
}
IKVPairInstance <IString, IDouble> kvpair = (IKVPairInstance <IString, IDouble>)Output_value.newInstance();
((IStringInstance)kvpair.Key).Value = ((IStringInstance)input.Key).Value;
((IDoubleInstance)kvpair.Value).Value = soma;
//using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"/home/cenez/workspace/java/hash-programming-environment-read-only/HPE_BackEnd/logReduce", true)){
// file.WriteLine("key="+((IStringInstance)kvpair.Key).Value+" : value="+((IDoubleInstance)kvpair.Value).Value);
//}
}
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 !!!");
}
private IDictionary <int, IList <int> > splitting_In_Left_Pivot_Right(IIteratorInstance <ICliqueNode> input_instance_value, string pivot, HashSet <int> P, HashSet <int> X)
{
IDictionary <int, IList <int> > res = new Dictionary <int, IList <int> >();
int pivot_number = int.Parse(pivot);
object o;
//Debug Block start
// string saida = "TaskRank="+this.Rank+" Chave="+pivot+" {"+System.Environment.NewLine;
//Debug Block end
while (input_instance_value.fetch_next(out o))
{
ICliqueNodeInstance node_instance = (ICliqueNodeInstance)o;
if (pivot_number < node_instance.IdInstance)
{
P.Add(node_instance.IdInstance);
}
if (pivot_number > node_instance.IdInstance)
{
X.Add(node_instance.IdInstance);
}
res [node_instance.IdInstance] = node_instance.NeighborsInstance;
//Debug Block start
// saida = saida+"<"+node_instance.IdInstance+", [";
// IEnumerator<int> neighbor = node_instance.NeighborsInstance.GetEnumerator ();
// while (neighbor.MoveNext ()) {
// saida = saida + neighbor.Current + " ";
// }
// saida = saida + "]>"+System.Environment.NewLine;
//Debug Block end
}
// saida = saida + "}"+System.Environment.NewLine;
// using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"./logCliqueReduce"+Rank, true)){
// file.WriteLine(saida);
// }
return(res);
}
private void graph_creator()
{
IIteratorInstance <IKVPair <IInteger, IIterator <GIF> > > input_instance_gif = (IIteratorInstance <IKVPair <IInteger, IIterator <GIF> > >)Collect_graph.Client;
IIteratorInstance <IKVPair <IInteger, GIF> > output_instance_gif = (IIteratorInstance <IKVPair <IInteger, GIF> >)Output_gif.Instance;
Feed_graph.Server = output_instance_gif;
IActionFuture sync_perform;
bool end_iteration = false;
while (!end_iteration) // take next chunk ...
{
Task_gusty.invoke(ITaskPortAdvance.READ_CHUNK);
Task_gusty.invoke(ITaskPortAdvance.PERFORM, out sync_perform);
IKVPairInstance <IInteger, IIterator <GIF> > kvpair = null;
object kvpair_object;
object o;
if (!input_instance_gif.has_next())
{
end_iteration = true;
}
while (input_instance_gif.fetch_next(out kvpair_object))
{
kvpair = (IKVPairInstance <IInteger, IIterator <GIF> >)kvpair_object;
Graph_values.Instance = kvpair;
Gusty_function.graph_creator();
}
sync_perform.wait();
}
//IActionFuture gusty_chunk_ready;
//Task_gusty.invoke (ITaskPortAdvance.CHUNK_READY, out gusty_chunk_ready); //***
output_instance_gif.finish();
//gusty_chunk_ready.wait ();
}
void outputFinalDistances(IIteratorInstance <IPathInfo> final_distances_instance, IStringInstance output_data_instance)
{
string output_string = "";
object o;
while (final_distances_instance.fetch_next(out o))
{
IPathInfoInstance path_info = (IPathInfoInstance)o;
DistanceInfo distance_info = (DistanceInfo)path_info.Value;
if (distance_info.info_type.Equals(Info.PATH_INFO_TYPE_DISTANCE_PARTIAL))
{
Console.WriteLine("OUTPUT : " + path_info.Value);
output_string += distance_info.vertex + " d " + distance_info.distance + System.Environment.NewLine;
}
else
{
throw new Exception("PathFlowImpl.IMasterImpl.outputFinalDistances: something goes wrong when reading output distances (unexpected result : " + distance_info + ")"
+ distance_info.info_type + " --- " + Info.PATH_INFO_TYPE_DISTANCE_PARTIAL);
}
}
output_data_instance.Value = output_string;
}
public void sendORVsToTarget()
{
IIteratorInstance <ORV> source_data_instance = (IIteratorInstance <ORV>)Source_data.Instance;
root = this.UnitRanks["target"][0];
object orv, last_orv = null;
Trace.WriteLine(WorldComm.Rank + ": START COMBINER SOURCE !!!");
while (source_data_instance.fetch_next(out orv))
{
last_orv = orv;
Trace.WriteLine(WorldComm.Rank + ": BEGIN SEND COMBINER SOURCE to " + root);
comm.Send <object>(orv, root, TAG_COMBINER_ORV);
Trace.WriteLine(WorldComm.Rank + ": END SEND COMBINER SOURCE to " + root);
}
Trace.WriteLine(WorldComm.Rank + ": BEGIN SEND FINISH COMBINER SOURCE to " + root);
comm.Send <object>(last_orv, root, TAG_COMBINER_ORV_FINISH);
Trace.WriteLine(WorldComm.Rank + ": END SEND FINISH COMBINER SOURCE to " + root);
Trace.WriteLine(WorldComm.Rank + ": FINISH COMBINER SOURCE !!!");
}
public override void main()
{
IStringInstance input_data_instance = (IStringInstance)Input_data.Instance;
input_data_instance.Value = readInput();
long t0 = (long)(DateTime.UtcNow - (new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc))).TotalMilliseconds;
Clique.go();
long t1 = (long)(DateTime.UtcNow - (new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc))).TotalMilliseconds;
IIteratorInstance <IKVPair <IString, ICliqueNode> > output_data_instance = (IIteratorInstance <IKVPair <IString, ICliqueNode> >)Output_data.Instance;
int sum = 0;
object o;
while (output_data_instance.fetch_next(out o))
{
IKVPairInstance <IString, ICliqueNode> KMV = (IKVPairInstance <IString, ICliqueNode>)o;
IStringInstance pivo = (IStringInstance)KMV.Key;
ICliqueNodeInstance cliqueNode = (ICliqueNodeInstance)KMV.Value;
sum += cliqueNode.IdInstance;
}
clearWriteFile("./outCliqueApp", "Soma:" + sum + "Tempo:" + (t1 - t0));
}
