Benchmarking – The Specifics

..........................................................................................................................................................
import java.io.*;
import java.net.*;

public class echo 
{
  public static void main(String[] args) throws Exception     
  {
    int iIterations = 1;
    try 
    {
        iIterations = Integer.parseInt(args[0]);
    } 
    catch(Exception e) { }
    EchoServer esServer = new EchoServer(0);
    new EchoClient(InetAddress.getLocalHost(), 
                   esServer.getPort(), iIterations);
  }
}

//Loopback echo-client thread
class EchoClient extends Thread 
{
    private static final String GREETING = "Hello World\n";
    private final InetAddress inetaServer;
    private final int         iPort;
    private final int         iIterations;
    public EchoClient(InetAddress inetaServer, int iPort, 
  int iIterations) 
    {
      this.inetaServer = inetaServer;
     this.iPort = iPort;
      this.iIterations = iIterations;
      start();
    }

    public void run() 
    {
      Socket socketFromServer = null;
      try 
      {
        socketFromServer = new Socket(inetaServer, iPort);
        BufferedReader in = new BufferedReader(new 
                                     InputStreamReader(
socketFromServer.getInputStream()
  )
                      );
        OutputStream out = 
socketFromServer.getOutputStream();

        byte[] bytesOut = GREETING.getBytes();
        String strIn = GREETING.trim();

        for(int i = 0; i < iIterations; ++i) 
        {
           out.write(bytesOut);
           out.flush();
           String strRead = in.readLine();
           if(!strRead.equals(strIn))
              throw new RuntimeException("client: \"" + 
strIn + "\" ne \"" + strRead + "\"");
        }
    } 
    catch(Exception e) 
    {
        e.printStackTrace();
    }

    try 
    {
        socketFromServer.close();
    } 
    catch(Exception e) { }
  }
}
//The main server thread

class EchoServer extends Thread 
{
    private static final int   BUFFER_SIZE = 1024;
    private final ServerSocket ssAccepting;
    private final int          iPort;

    public EchoServer(int iPort) throws IOException 
    {
       ssAccepting = new ServerSocket(iPort);
       this.iPort = ssAccepting.getLocalPort();
       start();
    }

    public final int getPort() 
    {
      return iPort;
    }

    public void run() 
    {
      byte bytesIn[] = new byte[BUFFER_SIZE];
      try 
      {
        Socket socketClient = ssAccepting.accept();
        InputStream in = socketClient.getInputStream();
        OutputStream out = socketClient.getOutputStream();
        int iLength, iCount = 0;

        while ((iLength = in.read(bytesIn)) != -1) 
        {
          out.write(bytesIn, 0, iLength);
          out.flush();
          iCount += iLength;
        } 

        System.out.println("server processed " + iCount + " 
   bytes");
      } 
      catch (Exception e) 
      {
        e.printStackTrace();
      }
    }
}

import java.text.*;
import java.lang.reflect.Array;

public class heapsort 
{
  public static final long IM = 139968;
  public static final long IA =   3877;
  public static final long IC =  29573;
  public static void main(String args[]) 
  {
    int N = Integer.parseInt(args[0]);
    NumberFormat nf = NumberFormat.getInstance();
    nf.setMaximumFractionDigits(10);
    nf.setMinimumFractionDigits(10);
    nf.setGroupingUsed(false);
    double []ary = (double[])Array.newInstance(double.class, 
                                       N+1);

    for (int i=1; i<=N; i++) 
    {
        ary[i] = gen_random(1);
    }

    heapsort(N, ary);
    System.out.print(nf.format(ary[N]) + "\n");
  }

  public static long last = 42;
  public static double gen_random(double max) 
 {
    return( max * (last = (last * IA + IC) % IM) / IM );
 }

  public static void heapsort(int n, double ra[]) 
  {
    int l, j, ir, i;
    double rra;
    l = (n >> 1) + 1;
    ir = n;
    for (;;) 
    {
        if (l > 1) 
        {
          rra = ra[--l];
        } 

        else 
        {
          rra = ra[ir];
          ra[ir] = ra[1];

          if (--ir == 1) 
          {
            ra[1] = rra;
            return;
          }
        }    
 

        i = l;
        j = l << 1;

        while (j <= ir) 
        {
          if (j < ir && ra[j] < ra[j+1]) { ++j; }
          if (rra < ra[j]) 
          {
            ra[i] = ra[j];
            j += (i = j);
          } 
          else 
          {
            j = ir + 1;
          }
        }
        ra[i] = rra;
    }
  }
}

..........................................................................................................................................................
using System;

class Toggle {
    public bool state = true;
    public Toggle(bool start_state) {
        this.state = start_state;
    }

    public bool value() {
        return(this.state);
    }

    public Toggle activate() {
        this.state = !this.state;
        return(this);
    }
}

class NthToggle : Toggle {
    int count_max = 0;
    int counter = 0;

    public NthToggle(bool start_state, int max_counter) : base(start_state) {

        this.count_max = max_counter;
        this.counter = 0;
    }

    public new NthToggle activate() {
        this.counter += 1;
        if (this.counter >= this.count_max) {
            this.state = !this.state;
            this.counter = 0;
        }
        return(this);
    }
}

class App {
    public static int Main(String[] args) {
        int n;

        n = System.Convert.ToInt32(args[0]);

        if(n < 1) n = 1;

        Toggle toggle1 = new Toggle(true);
        for (int i=0; i<5; i++) {
            Console.WriteLine((toggle1.activate().value()) ? "true" :
"false");
        }

        for (int i=0; i<n; i++) {
            Toggle toggle = new Toggle(true);
        }
        Console.WriteLine();  

        NthToggle ntoggle1 = new NthToggle(true, 3);

        for (int i=0; i<8; i++) {
            Console.WriteLine((ntoggle1.activate().value()) ? "true" : "false");
        }

        for (int i=0; i<n; i++) {
            NthToggle toggle = new NthToggle(true, 3);
        }
        return(0);
    }
}

..........................................................................................................................................................
program reversefile2;

uses Windows;

const MAX_READ = 4096;

// avoids using SysUtils and its initializations

function FileRead(Handle: THandle; var Buffer; Count: LongWord): Integer;

begin
  if not ReadFile(Handle, Buffer, Count, LongWord(Result), nil) then
    Result := -1;
end;

function FileWrite(Handle: THandle; const Buffer; Count: LongWord): Integer;

begin

  if not WriteFile(Handle, Buffer, Count, LongWord(Result), nil) then
    Result := -1;
end;

var buf: array of char;
    numRead: integer;
    inHandle,outHandle: THandle;
    filePos,i,e: cardinal;

begin
  inHandle:=GetStdHandle(STD_INPUT_HANDLE);
  outHandle:=GetStdHandle(STD_OUTPUT_HANDLE);
  setLength(buf, MAX_READ);
  numRead:=fileRead(inHandle,buf[0],MAX_READ);
  filePos:=0;

  while numRead>0 do begin
    inc(filePos,numRead);
    if integer(filePos)+MAX_READ-1>high(buf) then
      setLength(buf, (high(buf)+1)*2);
    numRead:=fileRead(inHandle,buf[filePos],MAX_READ);
  end;

  e:=filePos-1;

  for i:=filePos-2 downto 0 do
    if buf[i]=#10 then begin
      fileWrite(outHandle,buf[i+1],e-i);
      e:=i;
    end;
  fileWrite(outHandle,buf[0],e+1);
end.