public override void Map(Channel q, object map_arg) {
IList retval = new ArrayList();
IDictionary my_entry = new ListDictionary();
my_entry["node"] = _node.Address.ToString();
retval.Add(my_entry);
q.Enqueue(retval);
}
public override void Reduce(Channel q, object reduce_arg,
object current_result, RpcResult child_rpc) {
bool done = false;
ISender child_sender = child_rpc.ResultSender;
//the following can throw an exception, will be handled by the framework
object child_result = child_rpc.Result;
//child result is a valid result
if (current_result == null) {
q.Enqueue(new Brunet.Util.Pair<object, bool>(child_result, done));
return;
}
ArrayList retval = current_result as ArrayList;
IDictionary my_entry = (IDictionary) retval[0];
my_entry["next_con"] = child_sender.ToUri();
retval.AddRange((IList) child_result);
if (LogEnabled) {
ProtocolLog.Write(ProtocolLog.MapReduce,
String.Format("{0}: {1}, reduce list count: {2}.", this.TaskName, _node.Address, retval.Count));
}
q.Enqueue(new Brunet.Util.Pair<object, bool>(retval, done));
}
public override void Reduce(Channel q, object reduce_arg,
object current_result, RpcResult child_rpc) {
bool done = false;
//ISender child_sender = child_rpc.ResultSender;
//the following can throw an exception, will be handled by the framework
object child_result = child_rpc.Result;
//child result is a valid result
if (current_result == null) {
q.Enqueue(new Brunet.Util.Pair<object, bool>(child_result, done));
return;
}
IDictionary my_entry = current_result as IDictionary;
IDictionary value = child_result as IDictionary;
int max_height = (int) my_entry["height"];
int count = (int) my_entry["count"];
int y = (int) value["count"];
my_entry["count"] = count + y;
int z = (int) value["height"] + 1;
if (z > max_height) {
my_entry["height"] = z;
}
q.Enqueue(new Brunet.Util.Pair<object, bool>(my_entry, done));
}
/** Greedy routing. gen_arg is the Address of the destination
*/
public override void GenerateTree(Channel q, MapReduceArgs mr_args) {
object gen_arg = mr_args.GenArg;
Log("{0}: {1}, greedy generator called, arg: {2}.",
this.TaskName, _node.Address, gen_arg);
string address = gen_arg as string;
AHAddress a = (AHAddress) AddressParser.Parse(address);
ArrayList retval = new ArrayList();
ConnectionTable tab = _node.ConnectionTable;
ConnectionList structs = tab.GetConnections(ConnectionType.Structured);
Connection next_closest = structs.GetNearestTo((AHAddress) _node.Address, a);
if (next_closest != null) {
//arguments do not change at all
MapReduceInfo mr_info = new MapReduceInfo(next_closest.Edge, mr_args);
retval.Add(mr_info);
}
Log("{0}: {1}, greedy generator returning: {2} senders.",
this.TaskName, _node.Address, retval.Count);
//Send the result:
q.Enqueue(retval.ToArray(typeof(MapReduceInfo)));
}
/**
* Generates tree for bounded broadcast. Algorithm works as follows:
* The goal is to broadcast to all nodes in range [local_address, end).
* Given a range [local_address, b), determine all connections that belong to this range.
* Let the connections be b_1, b_2, ..... b_n.
* To connection bi assign the range [b_i, b_{i+1}).
* To the connection bn assign range [b_n, end).]
*/
public override void GenerateTree(Channel q, MapReduceArgs mr_args)
{
object gen_arg = mr_args.GenArg;
string end_range = gen_arg as string;
Log("generating child tree, range end: {0}.", end_range);
AHAddress end_addr = (AHAddress) AddressParser.Parse(end_range);
AHAddress start_addr = _node.Address as AHAddress;
//we are at the start node, here we go:
ConnectionTable tab = _node.ConnectionTable;
ConnectionList structs = tab.GetConnections(ConnectionType.Structured);
ArrayList retval = new ArrayList();
if (structs.Count > 0) {
Connection curr_con = structs.GetLeftNeighborOf(_node.Address);
int curr_idx = structs.IndexOf(curr_con.Address);
//keep going until we leave the range
int count = 0;
ArrayList con_list = new ArrayList();
while (count++ < structs.Count && ((AHAddress) curr_con.Address).IsBetweenFromLeft(start_addr, end_addr)) {
con_list.Add(curr_con);
//Log("adding connection: {0} to list.", curr_con.Address);
curr_idx = (curr_idx + 1)%structs.Count;
curr_con = structs[curr_idx];
}
Log("{0}: {1}, number of child connections: {2}",
this.TaskName, _node.Address, con_list.Count);
for (int i = 0; i < con_list.Count; i++) {
MapReduceInfo mr_info = null;
ISender sender = null;
Connection con = (Connection) con_list[i];
sender = (ISender) con.Edge;
//check if last connection
if (i == con_list.Count - 1) {
mr_info = new MapReduceInfo( (ISender) sender,
new MapReduceArgs(this.TaskName,
mr_args.MapArg, //map argument
end_range, //generate argument
mr_args.ReduceArg //reduce argument
));
Log("{0}: {1}, adding address: {2} to sender list, range end: {3}",
this.TaskName, _node.Address,
con.Address, end_range);
retval.Add(mr_info);
}
else {
string child_end = ((Connection) con_list[i+1]).Address.ToString();
mr_info = new MapReduceInfo( sender,
new MapReduceArgs(this.TaskName,
mr_args.MapArg,
child_end,
mr_args.ReduceArg));
Log("{0}: {1}, adding address: {2} to sender list, range end: {3}",
this.TaskName, _node.Address,
con.Address, child_end);
retval.Add(mr_info);
}
}
}
q.Enqueue( retval.ToArray(typeof(MapReduceInfo)));
}
public override void Reduce(Channel q, object reduce_arg, object current_val, RpcResult child_r) {
var rest = child_r.Result as IEnumerable;
//If we get here, the child didn't throw an exception
var result = new ArrayList();
AddEnum(result, current_val as IEnumerable);
AddEnum(result, rest);
q.Enqueue(new Brunet.Util.Pair<object, bool>(result, false));
}
public void ChannelTests() {
Channel c0 = new Channel();
bool e_event_fired = false;
c0.EnqueueEvent += delegate(object o, EventArgs arg) {
e_event_fired = true;
};
c0.Enqueue(0);
bool c_event_fired = false;
c0.CloseEvent += delegate(object o, EventArgs arg) {
c_event_fired = true;
};
c0.Close();
Assert.IsTrue(c_event_fired, "CloseEvent");
c0 = new Channel();
c0.CloseAfterEnqueue();
c_event_fired = false;
c0.CloseEvent += delegate(object o, EventArgs arg) {
c_event_fired = true;
};
c0.Enqueue(1); //This should close the channel:
Assert.IsTrue(c_event_fired, "CloseEvent on Enqueue");
Assert.IsTrue(c0.Closed, "Closed");
c0 = new Channel(1);
c_event_fired = false;
c0.CloseEvent += delegate(object o, EventArgs arg) {
c_event_fired = true;
};
c0.Enqueue(1); //This should close the channel:
Assert.IsTrue(c_event_fired, "CloseEvent on Enqueue");
Assert.IsTrue(c0.Closed, "Closed");
//Try with different starting values:
Random r = new Random();
int en_count;
for(int i = 0; i < 100; i++) {
int max_enqueues = r.Next(1, 1000);
c0 = new Channel(max_enqueues);
c_event_fired = false;
en_count = 0;
c0.CloseEvent += delegate(object o, EventArgs arg) {
c_event_fired = true;
};
c0.EnqueueEvent += delegate(object o, EventArgs arg) {
en_count++;
};
for(int j = 0; j < max_enqueues; j++) {
c0.Enqueue(j);
}
Assert.IsTrue(c_event_fired, "CloseEvent on Enqueue");
Assert.AreEqual(en_count, max_enqueues, "EnqueueEvent count");
Assert.IsTrue(c0.Closed, "Closed");
try {
c0.Enqueue(null);
Assert.IsTrue(false, "Enqueue after close didn't fail");
}
catch {
Assert.IsTrue(true, "Enqueue after close Got exception");
}
}
}
public override void Map(Channel q, object map_arg) {
IDictionary my_entry = new ListDictionary();
my_entry["count"] = 1;
my_entry["height"] = 1;
q.Enqueue( my_entry );
}
