# Class PiDistributed

java.lang.Object
org.apfloat.samples.Pi
org.apfloat.samples.PiParallel
org.apfloat.samples.PiDistributed

public class PiDistributed extends PiParallel
Calculates pi using a cluster of servers. The servers should be running `OperationServer`. The names and ports of the cluster nodes are read from the file `cluster.properties`, or a `ResourceBundle` by the name "cluster". The format of the property file is as follows:

    server1=hostname.company.com:1234
    server2=hostname2.company.com:2345
    server3=hostname3.company.com:3456
    weight1=100
    weight2=110
    weight3=50

The server addresses are specified as hostname:port. Weights can (but don't have to) be assigned to nodes to indicate the relative performance of each node, to allow distributing a suitable amount of work for each node. For example, `weight2` is the relative performance of `server2` etc. The weights must be integers in the range 1...1000.

Guidelines for configuring the servers:

- If the machines are not identical, give proper weights to every machine. This can improve performance greatly.
- If the machines are somewhat similar (e.g. same processor but different clock frequency), you can calculate the weight roughly as `clockFrequency * numberOfProcessors`. For example, a machine with two 1600MHz processors is four times as fast as a machine with one 800MHz processor.
- If the machines are very heterogenous, you can benchmark their performance by running e.g. `PiParallel` with one million digits. Remember to specify the correct number of CPUs on each machine.
- Different JVMs can have different performance. For example, Sun's Java client VM achieves roughly two thirds of the performance of the server VM when running this application.
- When running `OperationServer` on the cluster nodes, specify the number of worker threads for each server to be the same as the number of CPUs of the machine.
- Additionally, you should specify the number of processors correctly in the `apfloat.properties` file for each cluster server.

Similarly as with `PiParallel`, if some nodes have multiple CPUs, to get any performance gain from running many threads in parallel, the JVM must be executing native threads. If the JVM is running in green threads mode, there is no advantage of having multiple threads, as the JVM will in fact execute just one thread and divide its time to multiple simulated threads.

Version:
  1.9.0
Author:
  Mikko Tommila

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `protected static class`
  `PiDistributed.DistributedBinarySplittingPiCalculator`
  Distributed version of the binary splitting algorithm.
  `static class`
  `PiDistributed.DistributedChudnovskyPiCalculator`
  Class for calculating pi using the distributed Chudnovskys' binary splitting algorithm.
  `static class`
  `PiDistributed.DistributedRamanujanPiCalculator`
  Class for calculating pi using the distributed Ramanujan's binary splitting algorithm.
  `protected static class`
  `PiDistributed.Node`
  RemoteOperationExecutor that implements the weight property.

  ### Nested classes/interfaces inherited from class PiParallel

  `PiParallel.ParallelBinarySplittingPiCalculator, PiParallel.ParallelChudnovskyPiCalculator, PiParallel.ParallelRamanujanPiCalculator, PiParallel.ThreadLimitedOperation<T>`

  ### Nested classes/interfaces inherited from class Pi

  `Pi.AbstractBinarySplittingSeries, Pi.BinarySplittingPiCalculator, Pi.BinarySplittingProgressIndicator, Pi.BinarySplittingSeries, Pi.BorweinPiCalculator, Pi.ChudnovskyBinarySplittingSeries, Pi.ChudnovskyPiCalculator, Pi.GaussLegendrePiCalculator, Pi.RamanujanBinarySplittingSeries, Pi.RamanujanPiCalculator`

- ## Field Summary

  ### Fields inherited from class Pi

  `err, out`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static void`
  `main(String[] args)`
  Command-line entry point.

  ### Methods inherited from class Pi

  `getErr, getInt, getLong, getOut, getPrecision, getRadix, run, setErr, setOut`

  ### Methods inherited from class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Method Details

  - ### main

    public static void main(String[] args) throws IOException, ApfloatRuntimeException
    Command-line entry point.
    Parameters:
      `args` - Command-line parameters.
    Throws:
      `IOException` - In case writing the output fails.
      `ApfloatRuntimeException`