private void DoCalculation(CalculatePi _)
        {
            sum = 0;
            nrAnswers = 0;
            stopwatch = Stopwatch.StartNew();

            foreach (var range in Distribute(RangeTo, NrParts))
                worker.Tell(new Worker.CalculateRange(range));
        }
Exemple #2
0
        /// <summary>
        /// Kapselung der Erzeugung der Serie in eine Anzahl von gleichverteilten Einheiten
        /// </summary>
        /// <param name="calculatePi">Calculate pi.</param>
        private IEnumerable <Worker.CalculateRange> Distribute(CalculatePi calculatePi)
        {
            int rangeStartAt     = 0;
            int nrPartsRemaining = calculatePi.NrUnits;

            while (nrPartsRemaining > 0)
            {
                int rangeEndAt = rangeStartAt + (calculatePi.Series - rangeStartAt) / nrPartsRemaining;

                yield return(new Worker.CalculateRange(rangeStartAt, rangeEndAt));

                rangeStartAt = rangeEndAt + 1;
                nrPartsRemaining--;
            }
        }
Exemple #3
0
        /// <summary>
        /// Kommando Behandlung für CalculatePi
        /// </summary>
        /// <param name="calculatePi">Calculate Pi command</param>
        private void CalculatePiHandler(CalculatePi calculatePi)
        {
            // wer hat die Berechung ursprünglich angefordert?
            creator = Sender;

            // Initialwert der Summe
            sum = 0;

            // mit zählen nicht vergessen
            nrMissing = calculatePi.NrUnits;

            // der Router kümmert sich um die Verteilung
            foreach (var calculateRange in Distribute(calculatePi))
            {
                router.Tell(calculateRange);
            }
        }
        /// <summary>
        /// Kommando Behandlung für CalculatePi
        /// </summary>
        /// <param name="calculatePi">Calculate Pi command</param>
        private void CalculatePiHandler(CalculatePi calculatePi)
        {
            // wer hat die Berechung angefordert?
            creator = Sender;

            // Initialwert der Summe
            sum = 0;

            // mit zählen nicht vergessen
            nrMissing = calculatePi.NrUnits;

            // lassen wir verteilt rechnen
            foreach (var calculateRange in Distribute(calculatePi))
            {
                worker.Tell(calculateRange);
            }
        }
        /// <summary>
        /// Command Handler for CalculatePi.
        /// </summary>
        /// <param name="calculatePi">Calculate Pi command</param>
        /// <description>
        /// The calculation consists of these steps:
        ///  * initialize a sum with 0
        ///  * create the requested amount of workers
        ///  * spread the range from 0 to series among the workers
        ///  * sum up the workers' sum values
        /// </description>
        private void CalculatePiHandler(CalculatePi calculatePi)
        {
            creator = Sender;

            sum = 0;
            nrMissing = calculatePi.NrWorkers;

            int workersLeft = calculatePi.NrWorkers;
            int series = calculatePi.Series;

            int minWorkUnit = 0;
            while (workersLeft > 0)
            {
                int maxWorkUnit = minWorkUnit + (series - minWorkUnit) / workersLeft;
                var worker = Context.ActorOf<Worker>();
                worker.Tell(new Worker.CalculateRange(minWorkUnit, maxWorkUnit));

                minWorkUnit = maxWorkUnit + 1;
                workersLeft--;
            }
        }
        /// <summary>
        /// Command Handler for CalculatePi.
        /// </summary>
        /// <param name="calculatePi">Calculate Pi command</param>
        /// <description>
        /// The calculation consists of these steps:
        ///  * initialize a sum with 0
        ///  * create the requested amount of workers
        ///  * spread the range from 0 to series among the workers
        ///  * sum up the workers' sum values
        /// </description>
        private void CalculatePiHandler(CalculatePi calculatePi)
        {
            // remember who created this message to send back answer
            creator = Sender;

            // initial value for sum to be calculated
            sum = 0;

            // nr of missing result values for completed sum
            nrMissing = calculatePi.NrUnits;

            // split up to approximately same-sized units
            int unitsLeft = calculatePi.NrUnits;
            int minWorkUnit = 0;
            while (unitsLeft > 0)
            {
                int maxWorkUnit = minWorkUnit + (calculatePi.Series - minWorkUnit) / unitsLeft;
                worker.Tell(new Worker.CalculateRange(minWorkUnit, maxWorkUnit));

                minWorkUnit = maxWorkUnit + 1;
                unitsLeft--;
            }
        }