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)); }