コード例 #1
0
        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);
        }
コード例 #2
0
        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);
            }
        }
コード例 #3
0
        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();
        }
コード例 #4
0
        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;
            }
        }
コード例 #5
0
        public void emite()
        {
            string saida = ((IStringInstance)Input_data.Instance).Value;
            IIteratorInstance <IKVPair <IInteger, IPageNode> > output = (IIteratorInstance <IKVPair <IInteger, IPageNode> >)Output_data.Instance;

            double X = 0.0;

            string[] lines = saida.Split(new char[] { System.Environment.NewLine[0] });
            string[] pr    = lines[0].Split(' ');
            if (pr [0].Equals("X"))
            {
                X = double.Parse(pr [1]) / dic.Count;
            }
            else
            {
                System.Console.WriteLine("Error of index to X");
            }
            lines [0] = "";

            foreach (string line in lines)
            {
                if (!line.Trim().Equals(""))
                {
                    string[] prank = line.Split(' ');
                    //if (b && !prank [0].Equals ("X")) {
                    IKVPairInstance <IInteger, IPageNode> kvpair = dic [int.Parse(prank [0])];
                    IPageNodeInstance no = (IPageNodeInstance)kvpair.Value;
                    no.PgrankInstance = double.Parse(prank [1]) + X;
                    output.put(kvpair);
                    //}
                }
            }
            output.finish();
        }
コード例 #6
0
        public override void main()
        {
            count = 0;
            IKVPairInstance <IString, IIterator <ICliqueNode> > input = (IKVPairInstance <IString, IIterator <ICliqueNode> >)Input_values.Instance;
            IStringInstance pivot = (IStringInstance)input.Key;
            IIteratorInstance <ICliqueNode> input_value = (IIteratorInstance <ICliqueNode>)input.Value;

            bigCliques = new List <IList <int> > ();
            bigger     = 0;

            HashSet <int> upper = new HashSet <int>();
            HashSet <int> lower = new HashSet <int>();

            IDictionary <int, IList <int> > dicValues = splitting_In_Left_Pivot_Right(input_value, pivot.Value, upper, lower);

            IList <int> R = new List <int>();

            R.Add(int.Parse(pivot.Value));

            bronKerboschAlgorithm(1, dicValues, upper, R, lower);

            //if (count > 0) {
            IKVPairInstance <IString, ICliqueNode> kvpair = (IKVPairInstance <IString, ICliqueNode>)Output_value.newInstance();

            ((IStringInstance)kvpair.Key).Value            = pivot.Value;
            ((ICliqueNodeInstance)kvpair.Value).IdInstance = count;                     //bigCliques [0].Count;
            //((ICliqueNodeInstance)kvpair.Value).NeighborsInstance = bigCliques [0];
            //} else {
            //	IKVPairInstance<IString,ICliqueNode> kvpair = (IKVPairInstance<IString,ICliqueNode>)Output_value.newInstance ();
            //	((IStringInstance)kvpair.Key).Value = pivot.Value;
            //	((ICliqueNodeInstance)kvpair.Value).IdInstance = 0;
            //}
        }
コード例 #7
0
        public override void main()
        {
            IIntegerInstance  input_key   = (IIntegerInstance)Input_key.Instance;
            IPageNodeInstance input_value = (IPageNodeInstance)Input_value.Instance;
            IIteratorInstance <IKVPair <IString, IDouble> > output = (IIteratorInstance <IKVPair <IString, IDouble> >)Output_data.Instance;

            double slice = input_value.PgrankInstance;
            int    size  = input_value.NeighborsInstance.Count;

            IEnumerator <int> iterator = input_value.NeighborsInstance.GetEnumerator();

            while (iterator.MoveNext())
            {
                string n = iterator.Current.ToString();
                IKVPairInstance <IString, IDouble> kvpair = (IKVPairInstance <IString, IDouble>)Output_data.createItem();
                ((IStringInstance)kvpair.Key).Value   = n;
                ((IDoubleInstance)kvpair.Value).Value = slice / size;
                output.put(kvpair);
            }
            if (size == 0)
            {
                IKVPairInstance <IString, IDouble> kvpair = (IKVPairInstance <IString, IDouble>)Output_data.createItem();
                ((IStringInstance)kvpair.Key).Value   = "X";
                ((IDoubleInstance)kvpair.Value).Value = slice;
                output.put(kvpair);
            }
            IKVPairInstance <IString, IDouble> KV = (IKVPairInstance <IString, IDouble>)Output_data.createItem();

            ((IStringInstance)KV.Key).Value   = input_key.Value.ToString();
            ((IDoubleInstance)KV.Value).Value = 0.0;
            output.put(KV);
        }
コード例 #8
0
        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);
                }
            }
        }
コード例 #9
0
        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);
                    }
                }
            }
        }
コード例 #10
0
        public override void main()
        {
            Trace.WriteLine(WorldComm.Rank + ": STARTING BREAK IN LINE  (SPLIT FUNCTION)");
            IStringInstance input_data_instance = (IStringInstance)Input_data.Instance;
            IIteratorInstance <IKVPair <IInteger, IString> > output_data_instance = (IIteratorInstance <IKVPair <IInteger, IString> >)Output_data.Instance;

            string s = input_data_instance.Value;

            string[] lines        = s.Split(new char[] { System.Environment.NewLine[0] });
            int      line_counter = 0;

            foreach (string line in lines)
            {
                if (!line.Trim().Equals(""))
                {
                    Trace.WriteLine(WorldComm.Rank + ": LINE = " + line);
                    IKVPairInstance <IInteger, IString> line_pair = (IKVPairInstance <IInteger, IString>)Output_data.createItem();
                    ((IIntegerInstance)line_pair.Key).Value  = line_counter++;
                    ((IStringInstance)line_pair.Value).Value = line;
                    output_data_instance.put(line_pair);
                }
            }

            Trace.WriteLine(WorldComm.Rank + ": FINISH BREAK IN LINES #1 !!! " + output_data_instance.GetHashCode());
            output_data_instance.finish();
            Trace.WriteLine(WorldComm.Rank + ": FINISH BREAK IN LINES #2 !!!");
        }
コード例 #11
0
        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);
            }
        }
コード例 #12
0
        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;
            }
        }
コード例 #13
0
        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);
                            }
                        }
                    }
                }
            }
        }
コード例 #14
0
        private void file_reader()
        {
            string fileName = System.Environment.GetEnvironmentVariable("PATH_GRAPH_FILE");

            IInputFormatInstance extractor_input_format = (IInputFormatInstance)server.fetchFileContentObject();

            extractor_input_format.PARTITION_SIZE = partition_size;
            IDictionary <int, IInputFormatInstance> sub_formats = extractor_input_format.extractBins(fileName);

            this.PartitionTABLE = extractor_input_format.PartitionTABLE;

            foreach (IInputFormatInstance shard in sub_formats.Values)
            {
                IKVPairInstance <IInteger, IInputFormat> item = (IKVPairInstance <IInteger, IInputFormat>)client.createItem();
                int first_vertex_id_from_partition            = shard.firstVertex(shard.PARTID);
                ((IIntegerInstance)item.Key).Value = first_vertex_id_from_partition;                 //counter_write_global;
                item.Value = shard;
                client.put(item);

                counter_write_chunk++;                 //counter_write_global++;

                if (counter_write_chunk >= CHUNK_SIZE)
                {
                    Console.WriteLine("NEW CHUNK size=" + counter_write_chunk);
                    counter_write_chunk = 0;
                    client.finish();
                }
            }

            client.finish();

            client.finish();

            Console.WriteLine("FINISHING READING DATA SOURCE");
        }
コード例 #15
0
        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);
        }
コード例 #16
0
        public object newInstance()
        {
            IKVPairInstance <V, V> kv = (IKVPairInstance <V, V>)Vertices.newInstance();

            this.instance = new IEdgeBasicInstanceImpl <V, int> (((IVertexInstance)kv.Key).Id, ((IVertexInstance)kv.Value).Id);
            return(this.instance);
        }
コード例 #17
0
        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 ");
        }
コード例 #18
0
        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);
        }
コード例 #19
0
        public override void main()
        {
            int             done = 0;
            IStringInstance input_data_instance  = (IStringInstance)Input_data.Instance;
            IStringInstance output_data_instance = (IStringInstance)Output_data.Instance;
            IIteratorInstance <IPathInfo> initial_data_instance = (IIteratorInstance <IPathInfo>)Initial_data.Instance;
            IKVPairInstance <IInteger, IIterator <IPathInfo> > final_distances_instance = (IKVPairInstance <IInteger, IIterator <IPathInfo> >)Final_distances.Instance;
            IIntegerInstance termination_flag = (IIntegerInstance)Termination_flag.Instance;

            string setE = input_data_instance.Value;
            string setV = "1 c 0" + System.Environment.NewLine;
            IDictionary <int, int> vertices = new Dictionary <int, int>();

            foreach (string edge in setE.Split(System.Environment.NewLine.ToCharArray()))
            {
                if (edge.Length > 0)
                {
                    int vertex = edge [0];
                    if (!vertices.ContainsKey(vertex))
                    {
                        setV += edge [0] + " d " + int.MaxValue + System.Environment.NewLine;
                        vertices.Add(vertex, vertex);
                    }
                }
            }

            feedInitialData(setV + System.Environment.NewLine + setE, initial_data_instance);

            int count = 0;

            while (done == 0)
            {
                Console.WriteLine(Rank + ": ITERATION PATH_FLOW FAST GO ! - " + (++count));

                this.Path_flow.go();

                done = ((IIntegerInstance)final_distances_instance.Key).Value;

                termination_flag.Value = done;
                Set_termination_flag.go();

                if (done == 0)
                {
                    Trace.WriteLine(Rank + ": Exchange #1");
                    initial_data_instance.putAll((IIteratorInstance <IPathInfo>)final_distances_instance.Value);
                    initial_data_instance.finish();
                    Trace.WriteLine(Rank + ": Exchange #2");
                }
            }

            outputFinalDistances((IIteratorInstance <IPathInfo>)final_distances_instance.Value, output_data_instance);

            Trace.WriteLine(Rank + ": --- FINISH PATH_FLOW.GO !");
        }
コード例 #20
0
        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))
            {
            }
        }
コード例 #21
0
        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;
        }
コード例 #22
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);
            }
        }
コード例 #23
0
        public void apply()
        {
            string buffer = "";

            foreach (KeyValuePair <int, double> kv in Di)
            {
                buffer = buffer + kv.Key + " d " + kv.Value + System.Environment.NewLine;
            }

            IKVPairInstance <IString, IString> orv = (IKVPairInstance <IString, IString>)Output_value.newInstance();

            ((IStringInstance)orv.Key).Value   = "1";
            ((IStringInstance)orv.Value).Value = buffer;
        }
コード例 #24
0
        }                                            // 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++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
コード例 #25
0
        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;
        }
コード例 #26
0
        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++;
                            }
                        }
                    }
                }
            }
        }
コード例 #27
0
        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 ###############################");
        }
コード例 #28
0
        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");
        }
コード例 #29
0
        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 ();
        }
コード例 #30
0
        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 ");
        }