通讯编程

开发平台：
Visual C++

iostats.cc：源码内容
							// 
// iostats.cc      : Collect various statistics for Diffusion
// authors         : Chalermek Intanagonwiwat and Fabio Silva
//
// Copyright (C) 2000-2003 by the University of Southern California
// $Id: iostats.cc,v 1.2 2005/09/13 04:53:47 tomh Exp $
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License,
// version 2, as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
//
// Linking this file statically or dynamically with other modules is making
// a combined work based on this file.  Thus, the terms and conditions of
// the GNU General Public License cover the whole combination.
//
// In addition, as a special exception, the copyright holders of this file
// give you permission to combine this file with free software programs or
// libraries that are released under the GNU LGPL and with code included in
// the standard release of ns-2 under the Apache 2.0 license or under
// otherwise-compatible licenses with advertising requirements (or modified
// versions of such code, with unchanged license).  You may copy and
// distribute such a system following the terms of the GNU GPL for this
// file and the licenses of the other code concerned, provided that you
// include the source code of that other code when and as the GNU GPL
// requires distribution of source code.
//
// Note that people who make modified versions of this file are not
// obligated to grant this special exception for their modified versions;
// it is their choice whether to do so.  The GNU General Public License
// gives permission to release a modified version without this exception;
// this exception also makes it possible to release a modified version
// which carries forward this exception.
#include "iostats.hh"
DiffusionStats::DiffusionStats(int id, int warm_up_time)
{
  // Zero various counters
  num_bytes_recv_ = 0;
  num_bytes_sent_ = 0;
  num_packets_recv_ = 0;
  num_packets_sent_ = 0;
  num_bcast_bytes_recv_ = 0;
  num_bcast_bytes_sent_ = 0;
  num_bcast_packets_recv_ = 0;
  num_bcast_packets_sent_ = 0;
  num_new_messages_sent_ = 0;
  num_new_messages_recv_ = 0;
  num_old_messages_sent_ = 0;
  num_old_messages_recv_ = 0;
  num_interest_messages_sent_ = 0;
  num_interest_messages_recv_ = 0;
  num_data_messages_sent_ = 0;
  num_data_messages_recv_ = 0;
  num_exploratory_data_messages_sent_ = 0;
  num_exploratory_data_messages_recv_ = 0;
  num_pos_reinforcement_messages_sent_ = 0;
  num_pos_reinforcement_messages_recv_ = 0;
  num_neg_reinforcement_messages_sent_ = 0;
  num_neg_reinforcement_messages_recv_ = 0;
  // Initialize id and time
  node_id_ = id;
  warm_up_time_ = warm_up_time;
  GetTime(&start_);
}
void DiffusionStats::logIncomingMessage(Message *msg)
{
  NeighborStatsEntry *neighbor;
  // Ignore event if still warming up
  if (ignoreEvent())
    return;
  // We don't consider messages from local apps/filters
  if (msg->last_hop_ == LOCALHOST_ADDR)
    return;
  num_bytes_recv_ += (msg->data_len_ + sizeof(struct hdr_diff));
  num_packets_recv_++;
  if (msg->next_hop_ == BROADCAST_ADDR){
    num_bcast_packets_recv_++;
    num_bcast_bytes_recv_ += (msg->data_len_ + sizeof(struct hdr_diff));
  }
  if (msg->new_message_)
    num_new_messages_recv_++;
  else
    num_old_messages_recv_++;
  neighbor = getNeighbor(msg->last_hop_);
  neighbor->recv_messages_++;
  if (msg->next_hop_ == BROADCAST_ADDR)
    neighbor->recv_bcast_messages_++;
  switch (msg->msg_type_){
  case INTEREST:
    num_interest_messages_recv_++;
    
    break;
  case DATA:
    num_data_messages_recv_++;
    break;
  case EXPLORATORY_DATA:
    num_exploratory_data_messages_recv_++;
    break;
  case POSITIVE_REINFORCEMENT:
    num_pos_reinforcement_messages_recv_++;
    break;
  case NEGATIVE_REINFORCEMENT:
    num_neg_reinforcement_messages_recv_++;
    break;
  default:
    break;
  }
}
void DiffusionStats::logOutgoingMessage(Message *msg)
{
  NeighborStatsEntry *neighbor;
  // Ignore event if still warming up
  if (ignoreEvent())
    return;
  num_bytes_sent_ += (msg->data_len_ + sizeof(struct hdr_diff));
  num_packets_sent_++;
  if (msg->next_hop_ == BROADCAST_ADDR){
    num_bcast_packets_sent_++;
    num_bcast_bytes_sent_ += (msg->data_len_ + sizeof(struct hdr_diff));
  }
  if (msg->new_message_)
    num_new_messages_sent_++;
  else
    num_old_messages_sent_++;
  if (msg->next_hop_ != BROADCAST_ADDR){
    neighbor = getNeighbor(msg->next_hop_);
    neighbor->sent_messages_++;
  }
  switch (msg->msg_type_){
  case INTEREST:
    num_interest_messages_sent_++;
    
    break;
  case DATA:
    num_data_messages_sent_++;
    break;
  case EXPLORATORY_DATA:
    num_exploratory_data_messages_sent_++;
    break;
  case POSITIVE_REINFORCEMENT:
    num_pos_reinforcement_messages_sent_++;
    break;
  case NEGATIVE_REINFORCEMENT:
    num_neg_reinforcement_messages_sent_++;
    break;
  default:
    break;
  }
}
void DiffusionStats::printStats(FILE *output)
{
  NeighborStatsList::iterator itr;
  NeighborStatsEntry *neighbor;
  long seconds;
  long useconds;
  float total_time;
  // Compute elapsed running time
  GetTime(&finish_);
  seconds = finish_.tv_sec - start_.tv_sec;
  if (finish_.tv_usec < start_.tv_usec){
    seconds--;
    finish_.tv_usec += 1000000;
  }
  useconds = finish_.tv_usec - start_.tv_usec;
  total_time = (float) (1.0 * seconds) + ((float) useconds / 1000000.0);
  fprintf(output, "Diffusion Statsn");
  fprintf(output, "---------------nn");
  fprintf(output, "Node id : %dn", node_id_);
  fprintf(output, "Running time : %f secondsnn", total_time);
  fprintf(output, "Total bytes/packets sent    : %d/%dn",
	  num_bytes_sent_, num_packets_sent_);
  fprintf(output, "Total bytes/packets recv    : %d/%dn",
	  num_bytes_recv_, num_packets_recv_);
  fprintf(output, "Total BC bytes/packets sent : %d/%dn",
	  num_bcast_bytes_sent_, num_bcast_packets_sent_);
  fprintf(output, "Total BC bytes/packets recv : %d/%dn",
	  num_bcast_bytes_recv_, num_bcast_packets_recv_);
  fprintf(output, "n");
  fprintf(output, "Messagesn");
  fprintf(output, "--------n");
  fprintf(output, "Old               - Sent : %d - Recv : %dn",
	  num_old_messages_sent_, num_old_messages_recv_);
  fprintf(output, "New               - Sent : %d - Recv : %dn",
	  num_new_messages_sent_, num_new_messages_recv_);
  fprintf(output, "n");
  fprintf(output, "Interest          - Sent : %d - Recv : %dn",
	  num_interest_messages_sent_, num_interest_messages_recv_);
  fprintf(output, "Data              - Sent : %d - Recv : %dn",
	  num_data_messages_sent_, num_data_messages_recv_);
  fprintf(output, "Exploratory Data  - Sent : %d - Recv : %dn",
	  num_exploratory_data_messages_sent_, num_exploratory_data_messages_recv_);
  fprintf(output, "Pos Reinforcement - Sent : %d - Recv : %dn",
	  num_pos_reinforcement_messages_sent_,
	  num_pos_reinforcement_messages_recv_);
  fprintf(output, "Neg Reinforcement - Sent : %d - Recv : %dn",
	  num_neg_reinforcement_messages_sent_,
	  num_neg_reinforcement_messages_recv_);
  fprintf(output, "n");
  fprintf(output, "Neighbors Stats (in packets)n");
  fprintf(output, "----------------------------n");
  for (itr = nodes_.begin(); itr != nodes_.end(); ++itr){
    neighbor = *itr;
    if (neighbor){
      fprintf(output, "Node : %d - Sent(U/B/T) : %d/%d/%d - Recv(U/B/T) : %d/%d/%dn",
	      neighbor->id_, neighbor->sent_messages_, num_bcast_packets_sent_,
	      (neighbor->sent_messages_ + num_bcast_packets_sent_),
	      (neighbor->recv_messages_ - neighbor->recv_bcast_messages_),
	      neighbor->recv_bcast_messages_,
	      neighbor->recv_messages_);
    }
  }
  fprintf(output, "n");
  fprintf(output, "Key: U - Unicastn");
  fprintf(output, "     B - Broadcastn");
  fprintf(output, "     T - Totaln");
  fprintf(output, "n");
}
NeighborStatsEntry * DiffusionStats::getNeighbor(int id)
{
  NeighborStatsList::iterator itr;
  NeighborStatsEntry *new_neighbor;
  for (itr = nodes_.begin(); itr != nodes_.end(); ++itr){
    if ((*itr)->id_ == id)
      break;
  }
  if (itr == nodes_.end()){
    // New neighbor
    new_neighbor = new NeighborStatsEntry(id);
    nodes_.push_front(new_neighbor);
    return new_neighbor;
  }
  return (*itr);
}
bool DiffusionStats::ignoreEvent()
{
  struct timeval tv;
  GetTime(&tv);
  if ((start_.tv_sec + warm_up_time_) > tv.tv_sec)
    return true;
  return false;
}

						