private void readPair_OMK_OMVs()
{
Console.WriteLine(this.Rank + ": REDUCE 1");
IIteratorInstance <IKVPair <TKey, IIterator <TValue> > > input_instance = (IIteratorInstance <IKVPair <TKey, IIterator <TValue> > >)Collect_pairs.Client;
IIteratorInstance <IKVPair <OKey, OValue> > output_instance = (IIteratorInstance <IKVPair <OKey, OValue> >)Output.Instance;
Feed_pairs.Server = output_instance;
IActionFuture sync_perform;
// TODO: Dividir em chunks a saa de pares (OKey,OValue)
Console.WriteLine(this.Rank + ": REDUCER 2");
// object gusty_lock = new object ();
bool end_computation = false;
while (!end_computation) // new iteration
{
IDictionary <object, object> cont_dict = new Dictionary <object, object> ();
Console.WriteLine(this.Rank + ": REDUCER LOOP");
end_computation = true;
bool end_iteration = false;
while (!end_iteration) // take next chunk ...
{
Console.WriteLine(this.Rank + ": REDUCER ITERATE 1");
Task_gusty.invoke(ITaskPortAdvance.READ_CHUNK);
Task_gusty.invoke(ITaskPortAdvance.PERFORM, out sync_perform);
Console.WriteLine(this.Rank + ": REDUCER ITERATE 2");
IKVPairInstance <TKey, IIterator <TValue> > kvpair = null;
object kvpair_object;
if (!input_instance.has_next())
{
end_iteration = true;
}
else
{
end_computation = false;
}
int count = 0;
while (input_instance.fetch_next(out kvpair_object))
{
Console.WriteLine(this.Rank + ": REDUCER ITERATE INNER LOOP 3 count=" + count);
kvpair = (IKVPairInstance <TKey, IIterator <TValue> >)kvpair_object;
object acc_value;
if (!cont_dict.TryGetValue(kvpair.Key, out acc_value))
{
cont_dict[kvpair.Key] = new object();
}
else
{
((IDataInstance)Continue_value.Instance).ObjValue = acc_value;
}
Input_values.Instance = kvpair;
Gusty_function.go();
cont_dict [kvpair.Key] = ((IDataInstance)((IKVPairInstance <OKey, OValue>)Output_value.Instance).Value).ObjValue;
count++;
}
Console.WriteLine(this.Rank + ": REDUCER ITERATE 4 count=" + count);
sync_perform.wait();
Console.WriteLine(this.Rank + ": REDUCER ITERATE 5");
}
Console.WriteLine(this.Rank + ": REDUCER ITERATE END ITERATION");
int chunk_counter = 1;
IActionFuture gusty_chunk_ready;
Task_gusty.invoke(ITaskPortAdvance.CHUNK_READY, out gusty_chunk_ready); //***
foreach (KeyValuePair <object, object> output_pair in cont_dict)
{
IKVPairInstance <OKey, OValue> new_pair = (IKVPairInstance <OKey, OValue>)Output_value.newInstance();
new_pair.Key = output_pair.Key;
new_pair.Value = output_pair.Value;
output_instance.put(new_pair);
}
output_instance.finish();
gusty_chunk_ready.wait();
Console.WriteLine(this.Rank + ": REDUCER ITERATE FINISH");
}
Console.WriteLine(this.Rank + ": REDUCER FINISH ... ");
}
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 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;
}
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()
{
double di = int.MaxValue;
double dmin = int.MaxValue;
int done = 1;
// var t = Tuple.Create<string,int>("dd",333);
IKVPairInstance <IString, IIterator <IString> > input = (IKVPairInstance <IString, IIterator <IString> >)Input_values.Instance;
IStringInstance k = (IStringInstance)input.Key;
IIteratorInstance <IString> v = (IIteratorInstance <IString>)input.Value;
int k_int = int.Parse(k.Value);
if (!neighbours.ContainsKey(k_int))
{
neighbours [k_int] = new Dictionary <int, double> ();
}
string buffer = "";
object o;
while (v.fetch_next(out o))
{
IStringInstance item = (IStringInstance)o;
string[] values = item.Value.Split(' ');
switch (values[0][0])
{
case 'c':
double tmp = double.Parse(values [1]);
dmin = min(dmin, tmp);
break;
case 'd':
di = double.Parse(values [1]);
break;
default:
//neighbours [k_int] [int.Parse (values [0])] = double.Parse (values [1]);
IDictionary <int, double> output_neibours = neighbours[k_int];
int n = int.Parse(values [0]);
double d = 0.0;
if (!output_neibours.TryGetValue(n, out d))
{
output_neibours[n] = double.Parse(values [1]);
}
else
if (double.Parse(values [1]) < d)
{
output_neibours[n] = double.Parse(values [1]);
}
break;
}
}
dmin = min(dmin, di);
if (dmin != di)
{
foreach (KeyValuePair <int, double> kv in neighbours[k_int])
{
buffer = buffer + kv.Key + " c " + (kv.Value + dmin) + System.Environment.NewLine;
}
done = 0;
}
buffer = buffer + k.Value + " d " + dmin + " " + System.Environment.NewLine;
IKVPairInstance <IString, IString> orv = (IKVPairInstance <IString, IString>)Output_value.newInstance();
((IStringInstance)orv.Key).Value = done.ToString();
((IStringInstance)orv.Value).Value = buffer;
}
public override void main()
{
int di = int.MaxValue;
int dmin = int.MaxValue;
int done = 1;
Trace.WriteLine(Rank + ": START REDUCE FUNCTION");
IKVPairInstance <IInteger, IIterator <IPathInfo> > input_instance = (IKVPairInstance <IInteger, IIterator <IPathInfo> >)Input_values.Instance;
IIntegerInstance k = (IIntegerInstance)input_instance.Key;
IIteratorInstance <IPathInfo> v = (IIteratorInstance <IPathInfo>)input_instance.Value;
int k_int = k.Value;
if (!neighbours.ContainsKey(k_int))
{
neighbours [k_int] = new Dictionary <int, int> ();
}
object o;
while (v.fetch_next(out o))
{
IPathInfoInstance item = (IPathInfoInstance)o;
Info item_info = (Info)item.Value;
Trace.WriteLine(Rank + ": REDUCE FUNCTION LOOP " + item_info);
switch (item_info.info_type)
{
case Info.PATH_INFO_TYPE_DISTANCE_TRIAL:
DistanceInfo distance_item_info_1 = (DistanceInfo)item_info;
int tmp = distance_item_info_1.distance;
dmin = (int)min(dmin, tmp);
break;
case Info.PATH_INFO_TYPE_DISTANCE_PARTIAL:
DistanceInfo distance_item_info_2 = (DistanceInfo)item_info;
di = distance_item_info_2.distance;
break;
case Info.PATH_INFO_TYPE_EDGE:
EdgeInfo edge_item_info = (EdgeInfo)item_info;
IDictionary <int, int> output_neibours = neighbours[k_int];
int n = edge_item_info.vertex_other;
int d = 0;
if (!output_neibours.TryGetValue(n, out d))
{
output_neibours[n] = edge_item_info.weight;
}
else
if (edge_item_info.weight < d)
{
output_neibours[n] = edge_item_info.weight;
}
break;
}
}
Trace.WriteLine(Rank + ": REDUCE FUNCTION AFTER LOOP #1 ");
IKVPairInstance <IInteger, IIterator <IPathInfo> > orv = (IKVPairInstance <IInteger, IIterator <IPathInfo> >)Output_value.newInstance();
IIteratorInstance <IPathInfo> buffer = (IIteratorInstance <IPathInfo>)orv.Value;
Trace.WriteLine(Rank + ": REDUCE FUNCTION OUT LOOP #2 ");
//IPathInfo path_info = buffer.createItem();
dmin = (int)min(dmin, di);
if (dmin != di)
{
foreach (KeyValuePair <int, int> kv in neighbours[k_int])
{
//IPathInfoInstance path_info_instance = (IPathInfoInstance) path_info.newInstance ();
IPathInfoInstance path_info_instance = (IPathInfoInstance)buffer.createItem();
DistanceInfo distance_info = new DistanceInfo();
distance_info.info_type = Info.PATH_INFO_TYPE_DISTANCE_TRIAL;
distance_info.vertex = kv.Key;
distance_info.distance = kv.Value + dmin;
path_info_instance.Value = distance_info;
buffer.put(path_info_instance);
Trace.WriteLine(Rank + ": REDUCE FUNCTION OTHER LOOP " + distance_info);
}
done = 0;
}
((IIntegerInstance)orv.Key).Value = done;
IPathInfoInstance path_info_instance_2 = (IPathInfoInstance)buffer.createItem();
DistanceInfo distance_info_2 = new DistanceInfo();
distance_info_2.info_type = Info.PATH_INFO_TYPE_DISTANCE_PARTIAL;
distance_info_2.vertex = k.Value;
distance_info_2.distance = dmin;
path_info_instance_2.Value = distance_info_2;
buffer.put(path_info_instance_2);
Trace.WriteLine(Rank + ": REDUCE FUNCTION OTHER LOOP OUT " + distance_info_2);
buffer.finish();
Trace.WriteLine(Rank + ": FINISH REDUCE FUNCTION");
}
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;
//}
}
