scriptroute 0.4.14

data/lib/scriptroute/tulip/loss.rb

@@ -0,0 +1,145 @@
+module Scriptroute
+module Tulip
+
+class LossTrain
+  attr_reader :train;
+
+  def initialize(destination, intra_train, type, ttl)
+    @destination, @intra_train, @type, @ttl = destination, intra_train, type, ttl;
+    #(dsts, numpackets, intratrain, types, ttls, psizes, numtrains, intertrain) 
+    @train = Train2.new([destination], 3, @intra_train, [type], [ttl], [-1, 1000, -1], 1, 0);
+  end
+
+  def isLossy? 
+    return (@train.num_losses[0] > 0);
+  end
+
+  ##todo: principled treatment of pcapping
+  def wasPcapped? 
+    @train.packets.each_index { |j| 
+      @train.packets[0].each_index { |k|
+	pr = @train.packets[j][k];
+	return true if (!pr or !pr.probe or !pr.probe.time);
+      }
+    }
+    return false;
+  end
+
+  def to_s 
+    str = "";
+    str += "losstrain #{@destination} #{@intra_train} #{@type} #{@ttl}\n";
+    @train.packets.each_index { |j| 
+      @train.packets[0].each_index { |k|
+	pr = @train.packets[j][k];
+	if (pr and pr.probe and pr.probe.time) then
+	  stime, sid = pr.probe.time.to_f * 1000, pr.probe.packet.ip_id;
+	  rtime = (pr.response) ? pr.response.time.to_f * 1000 : -1;
+	  rid = (pr.response) ? pr.response.packet.ip_id : -1;
+	  src = (pr.response)? pr.response.packet.ip_src : -1;
+	  str += "#{src} %.3f +%.3fms %d %d\n" %[stime, rtime-stime, rid, sid];
+	else 
+	  str += "pcap overload\n";
+	end
+      }
+    }
+    return str;
+  end
+
+end
+
+class LossDoctor  
+
+  def analyze (hopDetails) 
+
+    hopDetails.each_index { |hop| 
+      next if (!hopDetails[hop]);
+      details = hopDetails[hop];
+      
+      valid = @total[hop] - @undesiredLosses[hop];
+#      printf("%d. %s ", $global_tpath.path[hop].hop, details[4]);
+      printf("%s ", $global_tpath.path[hop]);
+      printf("(ejected) ") if (@ejected.has_key?(hop));
+      rt = @total[hop] - @undesiredLosses[hop] - @noLosses[hop];
+      printf("rt=%.3f (%d/%d) ",(valid==0)? 0 : rt.to_f/valid, rt, valid);
+      if (details[3]) then
+	printf("fw=%.3f (%d/%d) ", @forwardLosses[hop].to_f/valid, @forwardLosses[hop], valid); 
+	consec = @noLosses[hop] - @reorderedResponses[hop];
+	consecR = (consec==0)? 0 : @consecutiveIPIDs[hop].to_f/consec;
+	printf("co=%.3f (%d/%d) ", consecR, @consecutiveIPIDs[hop], consec);
+	printf("ro=%.3f (%d/%d)", @reorderedResponses[hop].to_f/@noLosses[hop], @reorderedResponses[hop], @noLosses[hop]);
+      end
+      puts "";
+    }
+  end
+    
+  def initialize (hopDetails) 
+    @total = Hash.new(0);
+    @noLosses = Hash.new(0);
+    @undesiredLosses = Hash.new(0);
+    @forwardLosses = Hash.new(0);
+    @reorderedResponses = Hash.new(0);
+    @consecutiveIPIDs = Hash.new(0);
+    @ejected = Hash.new(0);
+    
+
+    (0..$count-1).each { |num|
+      startTime = Time.now;
+      hopDetails.each_index { |i| 
+  
+	next if (!hopDetails[i] or @ejected.has_key?(i));
+	details = hopDetails[i];
+	
+	#(destination, intra_train, type, ttl)
+	train = LossTrain.new(details[0], $spread/1000.0, details[2], details[1]);
+	puts "#{train}\n" if ($verbose>=10);
+
+	@total[i] += 1;
+	pkts = train.train.packets[0];
+
+	next if (train.wasPcapped?);
+
+	if (!train.isLossy?) then
+	  @noLosses[i] += 1; 
+	  if (details[3]) then
+	    ids = pkts.map { |p| p.response.packet.ip_id };
+	    if (ids[1] < ids[0] or ids[2] < ids[1]) then
+	      @reorderedResponses[i] += 1 if (ids[1] != 0);   #don't count routers that return 0 for big probes
+	    end
+	    if (ids[0] + 1 == ids[1] and ids[1] + 1 == ids[2]) then
+	      @consecutiveIPIDs[i] += 1;
+	    end
+	  end
+	else
+	  if (!pkts[0].response or !pkts[2].response) then
+	    @undesiredLosses[i] += 1;
+	  else 
+	    id0 = pkts[0].response.packet.ip_id;
+	    id2 = pkts[2].response.packet.ip_id;
+	    if (id0 == id2 - 1) then
+	      @forwardLosses[i] += 1;
+	    end
+	  end
+	  if (@noLosses[i] <= 0.25*@total[i] and @total[i] >= 10) then
+	    @ejected[i] = 1;
+	  end
+	end
+      }
+
+      if ($printFrequency > 0 and (num+1) % $printFrequency == 0  and num != $count-1 ) then
+	puts " ---- after #{num+1} measurements ----";
+	analyze(hopDetails);
+      end
+
+      sleepTime = startTime + $lag/1000.0 - Time.now;
+      if (sleepTime > 0) then Kernel.sleep(sleepTime); end
+    }
+
+    puts " ---- after #{$count} measurements ----";
+    analyze(hopDetails);
+    
+  end
+end
+
+
+end
+end

data/lib/scriptroute/tulip/queuing.rb

@@ -0,0 +1,248 @@
+module Scriptroute
+module Tulip
+
+
+class QueueTrain
+  attr_reader :train;
+
+  def initialize(dst, type, ttl) 
+    #(dsts, numpackets, resolution, types, ttls, shuffle=false) 
+    #@train = Train.new([dst], 2, 0, [type], [ttl]);
+    @train = Train.new([dst], 1, 0, [type], [ttl]);
+  end
+
+  def isLossy? 
+    ##losing one of the two timestamps all the time is ok.
+    return (@train.num_losses[0] > 1);
+  end
+
+#   def to_s 
+#     return @train.to_s;
+#   end
+
+  def to_s
+    str = "queuetrain: #{@train.dsts} (#{@train.types})\n";
+    @train.packets[0].each_index { |i| 
+      (@train.dsts).each_index { |j|
+	pr = @train.packets[j][i];
+	stime = pr.probe.time.to_f * 1000;
+	rtt = (pr.probe and pr.response) ? (pr.response.time - pr.probe.time) * 1000 : -1;
+	str += "#{@train.dsts[j]} %.3fms %.3f " %[rtt, stime];
+	if (@train.types[j] == "tstamp") then 
+	  rem_time =  (pr.response)? pr.response.packet.icmp_ttime : 0;
+	  str += "#{rem_time}";
+	end
+      }
+      str += "\n";
+    }
+    return str;
+  end
+
+end
+
+def convertByteOrder(wrong)
+  right = Array.new();
+  right[0], right[1], right[2], right[3] =  wrong & 255, 
+                                           (wrong & (255 << 8)) >> 8, 
+                                           (wrong & (255 << 16)) >> 16, 
+                                           (wrong & (255 << 24)) >> 24;
+  out = ( (right[0] << 24) + (right[1] << 16) + (right[2] << 8) + right[3]);
+  #puts "#{wrong} #{out} #{right.join(" ")}\n";
+  return out;
+end 
+
+def fixByteOrder (stamps) 
+  if (stamps.length > 4 and 
+      (stamps[0][1] > stamps[1][1] or 
+       stamps[1][1] > stamps[2][1] or 
+       stamps[2][1] > stamps[3][1] or 
+       stamps[3][1] > stamps[4][1] 
+       ) 
+      ) then
+    triplets = Array.new();
+    stamps.each_index { |i|
+      triplets[i] = Array.new();
+      triplets[i][0] = stamps[i][0];
+      triplets[i][1] = convertByteOrder(stamps[i][1]);
+      triplets[i][2] = stamps[i][2];                 ## a better way to do this would be to insert in converted byte order
+    }
+    return triplets;
+  end
+  return stamps;
+end
+
+def computeRTMed (stamps) 
+  rtts = Array.new();
+  stamps.each { |stamp|
+    rtts.push(stamp[2] - stamp[0]);
+  }
+  rtts.sort!;
+  if (rtts.length > 0) 
+    medianDiff = rtts[rtts.length/2] - rtts[0];
+    return [medianDiff, rtts.first, rtts.last];
+  else
+    return -100;
+  end
+end
+
+def computeFWMedCing (triplets) 
+  #  triplets = Array.new();
+  oldsend, oldrcv = 0,0;
+  #  stamps.each { |stamp|
+  #    triplets.push(stamp);
+  #  }
+  
+  ENV['datalinepattern'] ="newexp";
+  ENV['fieldseparator'] = ":";
+  ENV['hostfieldnum'] = "3";
+  ENV['sentfieldnum'] = "6";
+  ENV['receivedfieldnum'] = "7";
+  ENV['bouncedfieldnum'] = "9";
+  ENV['segmentsecs'] = "12";
+  ENV['writefixeddir'] = "./";
+  ENV['sourceskew'] = "-";
+  ENV['target'] = "1.1.1.1";
+  ENV['showquality'] = "1";
+  
+  pid = Process.pid;
+  tmp = File.new("/tmp/fixLC.#{pid}", "w");
+  
+  if (triplets.length == 0) then
+    return -100;
+  end
+  
+  base = triplets[0][0];
+  triplets.each_index { |j| 
+    tup = triplets[j];
+    tmp.puts "0.000:newexp:1.1.1.1:%u:0:%u:%u:0:%u" %[j, tup[0] - base, tup[1], tup[2] - base];
+  }
+  tmp.close();
+  cmd = sprintf("#{FIXCLOCK} /tmp/fixLC.#{pid}");
+  output = `#{cmd}`.split("\n");
+  match = nil;
+  quality = [nil, nil];
+  output.each { |o|
+    if ( o =~ "inferred stdroundtrip" ) then
+      words = o.split;
+      quality = [words[4], words[6]];
+    end
+  }
+  
+  otts = Array.new();
+  rejected = 0;
+  tmp = File.new("./fixLC.#{pid}.fix");
+  tmp.each { |line| 
+    words = line.split(":");
+    snd,rem,zero,rcv = words[5..8].map { |i| i.to_i; }
+    #    if (snd <= rem and rem <= rcv) then
+    otts.push(rem - snd);
+    #    else
+    #      rejected += 1;
+    #    end
+  }
+  tmp.close();
+  File.delete("/tmp/fixLC.#{pid}", "./fixLC.#{pid}.fix", "./fixLC.#{pid}.rej");
+  
+  #puts "conglib-warning: rejected #{rejected} cing corrections\n" if (rejected > 0);
+
+  otts.sort!;
+  #STDERR.puts "WARNING: too few ott samples: #{otts.length}" if (otts.length < 5);
+  
+  medianDiff = (otts.length > 0)? (otts[otts.length/2] - otts[0]) : -100;
+  #puts "otts (#{otts.length}, #{medianDiff}): #{otts.join(" ")}";
+  return [[medianDiff, otts.last], quality];
+end
+
+
+class QueuingDoctor 
+
+  def validOTT (ott, rtt) 
+    return false if (ott < 0);
+    #return false if (ott > 3 and rtt < 1);
+    #return false if (ott > rtt/2);
+    return true;
+  end
+
+  def analyze (hopDetails) 
+
+    hopDetails.each_index { |hop| 
+      next if (!hopDetails[hop]);
+      details = hopDetails[hop];
+
+      valid = @total[hop] - @ratelimited[hop];
+#      printf("%d. %s ", $global_tpath.path[hop].hop, details[4]);
+      printf("%s ", $global_tpath.path[hop]);
+      printf("(ejected) ") if (@ejected.has_key?(hop));
+      round = computeRTMed(@stamps[hop]);
+      printf("rt: median=%.3f min=%.3f max=%.3f ", round[0]+round[1], round[1], round[2]);
+      if (details[3]) then
+	triplets = fixByteOrder(@stamps[hop]);
+	cing = computeFWMedCing(triplets);
+	q = (cing[1][1].to_f==0)? 1 : cing[1][0].to_f/cing[1][1].to_f;
+	if (validOTT(cing[0][0], round[0])) then
+	  printf("fw: median=%.3f max=%s quality=%.3f (%s/%s)", cing[0][0], cing[0][1], q, cing[1][0], cing[1][1]);
+	else
+	  printf("fw: median=-1 max=-1 quality=-1");
+	end
+      end
+      puts "";
+    }
+  end
+    
+  def initialize (hopDetails) 
+
+    @total = Hash.new(0);
+    @ratelimited = Hash.new(0)
+    @stamps = Hash.new();
+    hopDetails.each_index { |i| @stamps[i] = Array.new() if (hopDetails[i]);}
+    @ejected = Hash.new();
+
+    ##todo: implement the correlation thingy
+    @pairs = Hash.new();
+    
+    (0..$count-1).each { |num|
+      startTime = Time.now;
+      hopDetails.each_index { |i| 
+	
+	next if (!hopDetails[i] or @ejected.has_key?(i));
+	details = hopDetails[i];
+
+	#(dst, types, ttl) 
+
+	#puts "before train = %.3f" % [Time.now.to_f*1000];
+	train = QueueTrain.new(details[0], details[2], details[1]);
+	#puts "after train =  %.3f" % [Time.now.to_f*1000];
+
+	puts "#{train}\n" if ($verbose>=10);
+    
+	@total[i] += 1;
+	if (train.isLossy?) then 
+	  @ratelimited[i] += 1;  
+	  @ejected[i] = 1 if (@ratelimited[i] >= 0.5*@total[i] and @total[i] >= 10);
+	else 
+	  p = train.train.packets[0][0];
+	  if (p and p.probe and p.response and p.probe.time and p.response.time) then 
+	    @stamps[i].push([p.probe.time.to_f * 1000.0, p.response.packet.icmp_ttime, p.response.time.to_f*1000.0]);
+	  else 
+	    @total[i] -= 1;
+	  end
+	end
+      }
+	
+      if ($printFrequency > 0 and (num+1) % $printFrequency == 0  and num != $count-1) then
+	puts " ---- after #{num+1} measurements ----";
+	analyze(hopDetails);
+      end
+
+      sleepTime = startTime + $lag/1000.0 - Time.now;
+      #puts "sleep = #{sleepTime} %.3f" % [Time.now.to_f*1000];
+      if (sleepTime > 0 and num != $count-1) then Kernel.sleep(sleepTime); end
+    }
+
+    puts " ---- after #{$count} measurements ----";
+    analyze(hopDetails);
+  end
+end
+
+end
+end

data/lib/scriptroute/tulip/reordering.rb

@@ -0,0 +1,129 @@
+module Scriptroute
+module Tulip
+
+
+class ReordTrain
+  attr_reader :destination,:intra_train, :type, :ttl, :train;
+
+  def initialize(destination, intra_train, type, ttl)
+    @destination, @intra_train, @type, @ttl =    
+      destination, intra_train, type, ttl;
+
+    #(dsts, numpackets, resolution, types, ttls, shuffle=false) 
+    @train = Train.new([@destination], 2, @intra_train, [@type], [@ttl]);
+  end
+
+  def isLossy? 
+    return (@train.num_losses[0] > 0);
+  end
+
+  def isRTro? 
+    return false if (isLossy?);
+    rt1, rt2 = [0,1].map { |v| @train.packets[0][v].response.time; }
+    (rt1 > rt2)? true : false;
+  end
+  
+  def isFWro? 
+    return false if (isLossy?);
+    id1, id2 = [0,1].map { |v| @train.packets[0][v].response.packet.ip_id; }
+    (id1 > id2)? true : false;
+  end
+
+  def wasPcapped? 
+    @train.packets[0].each_index { |k|
+      pr = @train.packets[0][k];
+      return true if (!pr or !pr.probe or !pr.probe.time) 
+    }
+    return false;
+  end  
+
+  def to_s 
+    str = "";
+    str += "reordtrain %s %s %s %s\n" % [@destination, @ttl, @type, @intra_train];
+    @train.packets[0].each_index { |k|
+      pr = @train.packets[0][k];
+      stime, sid = pr.probe.time.to_f * 1000, pr.probe.packet.ip_id;
+      rtime = (pr.response) ? pr.response.time.to_f * 1000 : -1;
+      sid = pr.probe.packet.ip_id;
+      rid = (pr.response) ? pr.response.packet.ip_id : -1;
+      src = (pr.response)? pr.response.packet.ip_src : -1;
+      str += "#{src} %.3f +%.3fms %d %d" %[stime, rtime-stime, rid, sid];
+      str += "\n";
+    }
+    return str;
+  end  
+end
+
+
+class ReorderingDoctor  
+
+  def analyze (hopDetails) 
+
+    hopDetails.each_index { |hop| 
+      next if (!hopDetails[hop]);
+      details = hopDetails[hop];
+      
+      valid = 1.0*@total[hop] - @ratelimited[hop];
+#      printf("%d. %s ", $global_tpath.path[hop].hop, details[4]);
+      printf("%s ", $global_tpath.path[hop]);
+#      printf("%d. %s %s ", $global_tpath.path[hop].hop, IPSocket.getname($global_tpath.path[hop].hop), details[4]);
+      printf("(ejected) ") if (@ejected.has_key?(hop));
+      printf("rt=%.3f (%d/%d) ", @rtreord[hop].to_f/valid, @rtreord[hop], valid);
+      if (details[3]) then
+        printf("fw=%.3f (%d/%d)\n", @fwreord[hop].to_f/valid, @fwreord[hop], valid) 
+      else
+        printf("\n")
+      end
+    }
+  end
+    
+  def initialize (hopDetails) 
+      
+    @total = Hash.new(0);
+    @fwreord = Hash.new(0);
+    @rtreord = Hash.new(0);
+    @ratelimited = Hash.new(0)
+    @ejected = Hash.new(0);
+      
+    (0..$count-1).each { |num|
+      startTime = Time.now;
+      hopDetails.each_index { |i| 
+	
+	next if (!hopDetails[i] or @ejected.has_key?(i));
+	details = hopDetails[i];
+	
+	#(destination, intra_train, type, ttl)
+	train = ReordTrain.new(details[0],  $spread/1000.0, details[2], details[1]);
+	puts "#{train}\n" if ($verbose>=10);
+	
+	next if (train.wasPcapped?);
+
+	@total[i] += 1;
+	if (train.isLossy?) then 
+	  @ratelimited[i] += 1;
+	  if ($skipRTrtrs and @ratelimited[i] >= 0.5*@total[i] and @total[i] >= 10) then
+	    @ejected[i] = 1;
+	  end
+	else
+	  @fwreord[i] += (train.isFWro?)? 1 : 0
+	  @rtreord[i] += (train.isRTro?)? 1 : 0
+	end
+      }
+
+      if ($printFrequency > 0 and (num+1) % $printFrequency == 0 and num != $count-1) then
+	puts " ---- after #{num+1} measurements ----";
+	analyze(hopDetails);
+      end
+      
+      sleepTime = startTime + $lag/1000.0 - Time.now;
+      if (sleepTime > 0) then Kernel.sleep(sleepTime); end
+    }
+    
+    puts " ---- after #{$count} measurements ----";
+    analyze(hopDetails);
+    
+  end
+end
+
+end
+end