import ox.CSO._
import ox.Format._

/**
   A stress-test for threading infrastructure, this program generates
   primes by recursively forking sieve pipes that pass the first number
   that appears on their input stream, then filtering out successive
   multiples.
   <p>
   In the present implementation of cso, each prime generated requires
   an additional thread.
   <pre>
   OS              Hardware                     Max Prime Reached
   --------------------------------------------------------------------  
   MAC OS X (Tiger)1GB PPC Mac Mini             22811   (2549th prime)
   MAC OS X    "   4GB 2x2.66ghz Dual Core Xeon 22811   (2549th prime)
   MAC OS X    "   2GB 1x2.00ghz Core Duo       22811   (2549th prime)
   Suse 9.2     0.75GB 1.8ghz IBM T30 (x86)     29027   (3158th prime)
   Fedora          2gb 2x AMD64X2 x86.64        179041  (16252nd prime)
   </pre>
   
   It seems likely that Linux (or at last the Linux Java implementation)
   is cleverer at allocating stack space for threads. 
   
   @author  Bernard Sufrin, Oxford
   @version $Revision: 395 $ $Date: 2008-07-21 16:55:24 +0100 (Mon, 21 Jul 2008) $

*/ 
object PrimesTest
{ def main(args: Array[String]) =
  { val n    = if (args.length==0) -1 else args(0).toInt
    val mid  = OneOne[int]("mid")
    val res  = OneOne[int]("res")
        (  sieve(mid, res)                             
        || proc("output")
           { var i=1; 
             repeat 
             { printf("%04d %5d%n", i, res?)
               i=i+1 
               if (i==n) stop
             } 
             printf("FINISHED%n") 
             res.close
           }  
        || proc("source") { var i=2; repeat { mid!i; i=i+1 } }
        )()
     exit
  }
  
  def noMult(n: int, in: InPort[int], out: OutPort[int]) : PROC =
      proc ("nomult"+n.toString)
      { 
        repeat
        { val m=in?;
          if (m%n!=0) out!m
        }
        in.close
        out.close
      }
  
  var sn = 0
  
  def sieve(in: InPort[int], out: OutPort[int]) : PROC =
      proc ("seive")
      {
        val n = in?;
        val mid = OneOne[int];
        attempt
        { out!n
          (noMult(n, in, mid) || sieve(mid, out))()
        }
        { 
          mid.close
          in.close
        }
      }
        
}