stats.java

DTNSim2 is a simulator for Delay-Tolerant Networks (DTNs) written in Java. It is based on Sushant Ja

			if (sh)
				out = msg.toString() + "C";
			else
				out = msg.toString() + " CREAT: " + time;
		}
		else
		{
			return false;
		}

		outFields.set(fieldNum, out);

		return writeStatsField(stat, output, outFields, inFields, fieldNum + 1, context);
	}

	private boolean writeMsgHistory(Stats stat, BufferedWriter output, ArrayList<String> outFields,
			ArrayList<String> inFields, int fieldNum, HashMap<Object, Object> context) throws IOException
	{
		if (context.get(STAT_TYPE_MSG) == null)
		{
			if (splitResults(stat, output, outFields, inFields, fieldNum, context, STAT_TYPE_MSG))
			{
				output.append("\n");
				return true;
			}

			return false;
		}

		ArrayList<StatEntry> arr = getDataContextMap(STAT_TYPE_MSG, context);

		if (arr == null)
			return false;

		Iterator<StatEntry> it = arr.iterator();

		boolean ret = false;

		while (it.hasNext())
		{
			StatMsgEntry e = (StatMsgEntry) it.next();

			if (!shouldInclude(STAT_TYPE_MSG, context.get(STAT_TYPE_MSG), arr, e))
				continue;

			String out = null;
			Message msg = null;

			msg = e.msg;

			if (e.event == MSG_CREATED)
			{
				out = "CREATED: " + e.time;
			}
			else if (e.event == MSG_DELIVERED)
			{
				out = "DELIVERED: " + e.time + " HIST: " + msg.getHistory();
			}
			else if (e.event == MSG_DROPPED_OOBUF)
			{
				out = "OOBUF_DROPPED: " + e.time + " HIST: " + msg.getHistory();
			}
			else
			{
				throw new RuntimeException("Unknown Message Event: " + e.event);
			}

			outFields.set(fieldNum, out);

			ret |= writeStatsField(stat, output, outFields, inFields, fieldNum + 1, context);
		}

		if (ret)
			output.append("\n");

		return ret;
	}

	public boolean writeAvgDelay(Stats stat, BufferedWriter output, ArrayList<String> outFields,
			ArrayList<String> inFields, int fieldNum, HashMap<Object, Object> context) throws IOException
	{
		double rSum = 0;
		double rCount = 0;
		Double f;
		String field = null;

		if (inFields.get(fieldNum).equals("%avg_send_delay_pred_ratio"))
			field = "%send_delay_pred_ratio";
		else
			field = "%create_delay_pred_ratio";

		HashMap<Object, ArrayList<StatEntry>> map = getData(STAT_TYPE_MSG);

		if (map == null)
			return false;

		Iterator<Entry<Object, ArrayList<StatEntry>>> it = map.entrySet().iterator();

		while (it.hasNext())
		{
			Entry<Object, ArrayList<StatEntry>> entry = it.next();

			int idx = (Integer) entry.getKey();

			ArrayList<StatEntry> arr = entry.getValue();

			assert arr != null : "Message ID = " + idx + " was issued, but such a message was not reported as created!";

			if (!shouldInclude(STAT_TYPE_MSG, entry.getKey(), arr, null))
				continue;

			f = getDelay(arr, field, entry.getKey());

			if (f != null && f < Double.POSITIVE_INFINITY && f != Double.NaN)
			{
				rSum += f.doubleValue();
				rCount += 1;
			}
		}

		if (rCount > 0)
		{
			outFields.set(fieldNum, String.format("%.2f", rSum / rCount));
		}
		else
		{
			outFields.set(fieldNum, "??");
		}

		return writeStatsField(stat, output, outFields, inFields, fieldNum + 1, context);
	}

	public boolean writeMsgDelay(Stats stat, BufferedWriter output, ArrayList<String> outFields,
			ArrayList<String> inFields, int fieldNum, HashMap<Object, Object> context) throws IOException
	{
		if (context.get(STAT_TYPE_MSG) == null)
		{
			return splitResults(stat, output, outFields, inFields, fieldNum, context, STAT_TYPE_MSG);
		}

		ArrayList<StatEntry> arr = getDataContextMap(STAT_TYPE_MSG, context);

		if (arr == null)
			return false;

		Double delay = null;

		delay = getDelay(arr, inFields.get(fieldNum), context.get(STAT_TYPE_MSG));

		// This value should be skipped.
		if (delay == null)
			return false;

		outFields.set(fieldNum, String.format("%.2f", delay.doubleValue()));

		return writeStatsField(stat, output, outFields, inFields, fieldNum + 1, context);
	}

	public boolean writeStatsField(Stats stat, BufferedWriter output, ArrayList<String> outFields,
			ArrayList<String> inFields, int fieldNum, HashMap<Object, Object> context) throws IOException
	{
		if (fieldNum >= inFields.size())
		{
			int i, s = outFields.size();

			for (i = 0; i < s; ++i)
			{
				output.append(outFields.get(i));

				if (i + 1 < s)
					output.append(";\t");
			}

			output.append("\n");

			return true;
		}

		String field = inFields.get(fieldNum);
		StatVals statVals = stat.getStatVals();

		String out = null;

		if (field.startsWith("%"))
		{
			if (knownFields != null && knownFields.get(field) != null)
			{
				return knownFields.get(field).writeStatsField(stat, output, outFields, inFields, fieldNum, context);
			}
			else if (field.equals("%delivery_ratio") || field.equals("%ratio"))
			{
				out = String.format("%.2f", 100.0f * statVals.delivRatio) + "%";
			}
			else if (field.equals("%ack_ratio"))
			{
				out = String.format("%.2f", 100.0f * statVals.ACKRatio) + "%";
			}
			else if (field.equals("%avg_delivery_time") || field.equals("%avg_time"))
			{
				out = String.format("%.2f", statVals.avgDelivTime);
			}
			else if (field.equals("%avg_ack_time"))
			{
				out = String.format("%.2f", statVals.avgACKTime);
			}
			else if (field.equals("%total_msgs") || field.equals("%created"))
			{
				out = Long.toString(statVals.msgsCreated);
			}
			else if (field.equals("%total_msgs_size") || field.equals("%created_size"))
			{
				out = Long.toString(statVals.msgsCreatedDataSize + statVals.msgsCreatedProtoSize);
			}
			else if (field.equals("%total_msgs_data_size") || field.equals("%created_data_size"))
			{
				out = Long.toString(statVals.msgsCreatedDataSize);
			}
			else if (field.equals("%total_msgs_proto_size") || field.equals("%created_proto_size"))
			{
				out = Long.toString(statVals.msgsCreatedProtoSize);
			}
			else if (field.equals("%delivered_msgs") || field.equals("%delivered"))
			{
				out = Long.toString(statVals.msgsDelivered);
			}
			else if (field.equals("%delivered_msgs_size") || field.equals("%delivered_size"))
			{
				out = Long.toString(statVals.msgsDeliveredDataSize + statVals.msgsDeliveredProtoSize);
			}
			else if (field.equals("%delivered_msgs_data_size") || field.equals("%delivered_data_size"))
			{
				out = Long.toString(statVals.msgsDeliveredDataSize);
			}
			else if (field.equals("%delivered_msgs_proto_size") || field.equals("%delivered_proto_size"))
			{
				out = Long.toString(statVals.msgsDeliveredProtoSize);
			}
			else if (field.equals("%acked_msgs") || field.equals("%acked"))
			{
				out = Long.toString(statVals.msgsACKed);
			}
			else if (field.equals("%acked_msgs_size") || field.equals("%acked_size"))
			{
				out = Long.toString(statVals.msgsACKedDataSize + statVals.msgsACKedProtoSize);
			}
			else if (field.equals("%acked_msgs_data_size") || field.equals("%acked_data_size"))
			{
				out = Long.toString(statVals.msgsACKedDataSize);
			}
			else if (field.equals("%acked_msgs_proto_size") || field.equals("%acked_proto_size"))
			{
				out = Long.toString(statVals.msgsACKedProtoSize);
			}
			else if (field.equals("%dropped_oobuf_msgs") || field.equals("%dropped_oobuf"))
			{
				out = Long.toString(statVals.msgsDroppedOOBuf);
			}
			else if (field.equals("%contacts_used"))
			{
				out = Long.toString(statVals.cntUsed);
			}
			else if (field.equals("%total_data_sent"))
			{
				out = Long.toString(statVals.dataSize);
			}
			else if (field.equals("%total_proto_sent"))
			{
				out = Long.toString(statVals.protoSize);
			}
			else if (field.equals("%total_sent"))
			{
				out = Long.toString(statVals.dataSize + statVals.protoSize);
			}
			else if (field.equals("%avg_data_sent"))
			{
				out = String.format("%.2f", statVals.avgDataSize);
			}
			else if (field.equals("%avg_proto_sent"))
			{
				out = String.format("%.2f", statVals.avgProtoSize);
			}
			else if (field.equals("%data_trans_num"))
			{
				out = Long.toString(statVals.dataTransNum);
			}
			else if (field.equals("%proto_trans_num"))
			{
				out = Long.toString(statVals.routingTransNum);
			}
			else if (field.equals("%avg_trans_data_sent"))
			{
				if (statVals.dataTransNum > 0)
					out = String.format("%.2f", (((double) statVals.dataSize) / statVals.dataTransNum));
				else
					out = "0";
			}
			else if (field.equals("%avg_trans_proto_sent"))
			{
				if (statVals.routingTransNum > 0)
					out = String.format("%.2f", (((double) statVals.dataSize) / statVals.routingTransNum));
				else
					out = "0";
			}
			else if (field.equals("%avg_msg_data_sent"))
			{
				if (statVals.msgsCreated > 0)
					out = String.format("%.2f", (((double) statVals.dataSize) / statVals.msgsCreated));
				else
					out = "0";
			}
			else if (field.equals("%avg_msg_proto_sent"))
			{
				if (statVals.msgsCreated > 0)
					out = String.format("%.2f", (((double) statVals.protoSize) / statVals.msgsCreated));
				else
					out = "0";
			}
			else if (field.equals("%proto_overhead"))
			{
				out = String.format("%.2f", 100.0f * statVals.protoOverhead) + "%";
			}
			else if (field.equals("%msg_status") || field.equals("%msg_short_status"))
			{
				return writeMsgStatus(stat, output, outFields, inFields, fieldNum, context);
			}
			else if (field.equals("%msg_history"))
			{
				return writeMsgHistory(stat, output, outFields, inFields, fieldNum, context);
			}
			else if (field.equals("%avg_send_delay_pred_ratio") || field.equals("%avg_create_delay_pred_ratio"))
			{
				return writeAvgDelay(stat, output, outFields, inFields, fieldNum, context);
			}
			else if (field.equals("%send_delay_pred") || field.equals("%send_delay_real")
					|| field.equals("%create_delay_pred") || field.equals("%create_delay_real")
					|| field.equals("%send_delay_pred_ratio") || field.equals("%create_delay_pred_ratio"))
			{
				return writeMsgDelay(stat, output, outFields, inFields, fieldNum, context);
			}
		}

		if (out == null)
		{
			out = field;
		}

		outFields.set(fieldNum, out);

		return writeStatsField(stat, output, outFields, inFields, fieldNum + 1, context);
	}

	private void writeStats(OutputDesc outputDesc, BufferedWriter output) throws IOException
	{
		ArrayList<String> fields = new ArrayList<String>(outputDesc.fields);

		currentStatVals = null;

		writeStatsField(this, output, fields, outputDesc.fields, 0, new HashMap<Object, Object>());
	}

	private Double getDelay(ArrayList<StatEntry> entries, String field, Object cntOb)
	{
		Iterator<StatEntry> it = entries.iterator();
		Message msgCreated = null;

		while (it.hasNext())
		{
			StatMsgEntry e = (StatMsgEntry) it.next();

			if (!shouldInclude(STAT_TYPE_MSG, cntOb, entries, e))
				continue;

			if (e.event == Stats.MSG_CREATED)
			{
				assert msgCreated == null;

				msgCreated = e.msg;
			}
			else if (e.event == Stats.MSG_DELIVERED)
			{
				assert msgCreated != null;
				Double f = null, f2 = null;

				if (field.equals("%send_delay_pred"))
				{
					f = (Double) e.msg.getData(MSG_SEND_PRED_DELAY);

					if (f == null)
						return Double.NaN;

					return f;
				}
				else if (field.equals("%send_delay_real"))
				{
					f = (Double) e.msg.getData(MSG_SEND_TIME);

					if (f == null)
						return Double.NaN;

					return new Double(e.time - f.doubleValue());
				}
				else if (field.equals("%create_delay_pred"))
				{
					f = (Double) e.msg.getData(MSG_CREATE_PRED_DELAY);

					if (f == null)
						return Double.NaN;

					return f;
				}
				else if (field.equals("%create_delay_real"))
				{
					f = (Double) e.msg.getCreationTime();

					if (f == null)
						return Double.NaN;

					return new Double(e.time - f.doubleValue());
				}
				else if (field.equals("%send_delay_pred_ratio"))
				{
					f = (Double) e.msg.getData(MSG_SEND_PRED_DELAY);

					f2 = (Double) e.msg.getData(MSG_SEND_TIME);

					if (f == null || f2 == null)
						return Double.NaN;

					f2 = new Double(e.time - f2.doubleValue());

					return new Double(f2 / f);
				}
				else if (field.equals("%create_delay_pred_ratio"))
				{
					f = (Double) e.msg.getData(MSG_CREATE_PRED_DELAY);

					if (f == null)
						return Double.NaN;

					f2 = e.msg.getCreationTime();

					f2 = new Double(e.time - f2.doubleValue());

					return new Double(f2 / f);
				}
				else
				{
					throw new RuntimeException("Unknown prediction field type: " + field);
				}
			}
		}

		if (msgCreated != null)
		{
			Double f;

			if (field.equals("%send_delay_pred"))
			{
				f = (Double) msgCreated.getData(MSG_SEND_PRED_DELAY);

				if (f == null)
					return Double.NaN;

				return f;
			}
			else if (field.equals("%send_delay_real"))
			{
				return Double.NaN;
			}
			else if (field.equals("%create_delay_pred"))
			{
				f = (Double) msgCreated.getData(MSG_CREATE_PRED_DELAY);

				if (f == null)
					return Double.NaN;

				return f;
			}
			else if (field.equals("%create_delay_real"))
			{
				return Double.NaN;
			}
			else if (field.equals("%send_delay_pred_ratio"))
			{
				return Double.NaN;
			}
			else if (field.equals("%create_delay_pred_ratio"))
			{
				return Double.NaN;
			}
			else
			{
				throw new RuntimeException("Unknown prediction field type: " + field);
			}
		}

		return null;
	}

	// We override parseLocalCommand from CommandParser - we need
	// informationabout complete set of parameters in each input line
	public CommandStatus parseLocalCommand(String cmd, ArrayList<ArrayList<String>> args, String parentPath)
	{
		CommandStatus ret;

		outputDesc = new OutputDesc();

		ArrayList<String> first = args.get(0);
		args.remove(0);

		if (first.size() != 1)
		{
			return new CommandStatus("Wrong stats command: " + first);
		}

		if (first.get(0).equals("print"))
		{
			filtersToUse = null;

			ret = super.parseLocalCommand(cmd, args, parentPath);

			if (ret == null || ret.getStatus() != CommandStatus.COMMAND_OK)
				return ret;

			if (outputDesc.fileName == null || outputDesc.fileName.length() < 1)
			{
				return new CommandStatus("You have to provide a file name for the operation with: file=name.");
			}

			if (outputDesc.fields.size() < 1)
			{
				return new CommandStatus(
						"You have to provide at least one data field with: data=header=type or data=type.");
			}

			if (outputDesc.fields.size() != outputDesc.headers.size() && outputDesc.headers.size() != 0)
			{
				return new CommandStatus("You have to provide header for all or for none of the data fields!");
			}

			if (!outputDesc.fileFormat.equalsIgnoreCase("csv"))
			{
				return new CommandStatus("Currently the only file format allowed is 'csv'");
			}

			File outputFile = new File(parentPath, outputDesc.fileName);
			boolean writeHeaders = false;

			if (!outputFile.exists() && outputDesc.headers.size() > 0)
				writeHeaders = true;

			BufferedWriter output = null;