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