Simulation Simplified
17. A DOS Attack
Class WebServer02

import edu.rit.numeric.ExponentialPrng;
import edu.rit.numeric.ListSeries;
import edu.rit.numeric.ListXYSeries;
import edu.rit.numeric.Series;
import edu.rit.numeric.plot.Plot;
import edu.rit.sim.Event;
import edu.rit.sim.Simulation;
import edu.rit.util.Random;
import java.util.LinkedList;
public class WebServer02
   {
   private static double lambda_L;
   private static double lambda_U;
   private static double lambda_D;
   private static double mu;
   private static int Q;
   private static int R;
   private static long seed;
   private static ListXYSeries meanWaitTimeVsLambda;
   private static ListXYSeries dropFractionVsLambda;
   private static Random prng;
   private static ExponentialPrng requestPrng;
   private static ExponentialPrng serverPrng;
   private static LinkedList<Request> requestQueue;
   private static int requestCount;
   private static int dropCount;
   private static ListSeries waitTime;
   private static Simulation sim;

   public static void main
      (String[] args)
      {
      if (args.length != 7) usage();
      lambda_L = Double.parseDouble (args[0]);
      lambda_U = Double.parseDouble (args[1]);
      lambda_D = Double.parseDouble (args[2]);
      mu = Double.parseDouble (args[3]);
      Q = Integer.parseInt (args[4]);
      R = Integer.parseInt (args[5]);
      seed = Long.parseLong (args[6]);
      meanWaitTimeVsLambda = new ListXYSeries();
      dropFractionVsLambda = new ListXYSeries();
      prng = Random.getInstance (seed);
      System.out.printf
         ("Mu = %.3f, Q = %d, R = %d, seed = %d%n",
          mu, Q, R, seed);
      System.out.printf ("        --Wait time---  Drop%n");
      System.out.printf ("Lambda  Mean    Stddev  Fraction%n");
      double lambda;
      for (int r = 0;
            (lambda = lambda_L + r*lambda_D) <= lambda_U;
            ++ r)
         {
         requestPrng = new ExponentialPrng (prng, lambda);
         serverPrng = new ExponentialPrng (prng, mu);
         requestQueue = new LinkedList<Request>();
         requestCount = 0;
         dropCount = 0;
         waitTime = new ListSeries();
         sim = new Simulation();
         generateRequest();
         sim.run();
         Series.Stats wt = waitTime.stats();
         double df = ((double) dropCount)/((double) R);
         meanWaitTimeVsLambda.add (lambda, wt.mean);
         dropFractionVsLambda.add (lambda, df);
         System.out.printf ("%-8.3f%-8.3f%-8.3f%-8.3f%n",
            lambda, wt.mean, wt.stddev, df);
         }
      new Plot()
         .plotTitle
            ("WebServer02, \u03BC="+mu+", Q="+Q+", R="+R)
         .xAxisTitle ("Mean arrival rate \u03BB")
         .yAxisTitle ("Mean wait time")
         .xySeries (meanWaitTimeVsLambda)
         .getFrame()
         .setVisible (true);
      new Plot()
         .plotTitle
            ("WebServer02, \u03BC="+mu+", Q="+Q+", R="+R)
         .xAxisTitle ("Mean arrival rate \u03BB")
         .yAxisTitle ("Drop fraction")
         .xySeries (dropFractionVsLambda)
         .getFrame()
         .setVisible (true);
      }

   private static class Request
      {
      private double startTime;
      public Request()
         {
         startTime = sim.time();
         }
      public double waitTime()
         {
         return sim.time() - startTime;
         }
      }

   private static void generateRequest()
      {
      addToQueue (new Request());
      if (++ requestCount < R)
         {
         sim.doAfter (requestPrng.next(), new Event()
            {
            public void perform() { generateRequest(); }
            });
         }
      }

   private static void addToQueue
      (Request request)
      {
      if (requestQueue.size() < Q)
         {
         requestQueue.add (request);
         if (requestQueue.size() == 1) startServing();
         }
      else
         {
         ++ dropCount;
         }
      }

   private static void startServing()
      {
      sim.doAfter (serverPrng.next(), new Event()
         {
         public void perform() { removeFromQueue(); }
         });
      }

   private static void removeFromQueue()
      {
      waitTime.add (requestQueue.removeFirst().waitTime());
      if (requestQueue.size() > 0) startServing();
      }

   private static void usage()
      {
      System.err.println
         ("Usage: java WebServer02 <lambda_L> <lambda_U> "+
          "<lambda_D> <mu> <Q> <R> <seed>");
      System.exit (1);
      }
   }