コード例 #1
0
ファイル: AlgorithmRunner.cs プロジェクト: chiwakii/mai
        /// <summary>
        /// Runs the algorithm.
        /// </summary>
        /// <param name="refreshRate"></param>
        /// <param name="ComputationLimit"></param>
        /// <param name="Batch"></param>
        /// <param name="maxPathLength"></param>
        /// <returns></returns>
        public Results Run(long refreshRate, bool Batch, double computationLimitCeilingRatio,
                           string Alg, int ComputationLimit, Metric OptimalPathLength, string File,
                           bool Dynamic)
        {
            if (Algorithm is RealTimeAlgorithm <GenericGridWorldStaticState,
                                                GenericGridWorldDynamicState> )
            {
                (Algorithm as RealTimeAlgorithm <GenericGridWorldStaticState,
                                                 GenericGridWorldDynamicState>).SetComputationLimit(ComputationLimit);
            }
            Path <GenericGridWorldStaticState, GenericGridWorldDynamicState> path     = null;
            Path <GenericGridWorldStaticState, GenericGridWorldDynamicState> fullPath =
                new Path <GenericGridWorldStaticState, GenericGridWorldDynamicState>(
                    (GenericGridWorldDynamicState)null);
            long          MaxMemoryUsage     = 0;
            int           numStops           = 0;
            List <double> ComputationTimes   = new List <double>( );
            List <double> Expansions         = new List <double>( );
            double        LastExpansions     = 0;
            long          ComputationTimeMax = long.MinValue;

            if (!Batch)
            {
#if OpenGl
                if (vis != null)
                {
                    vis.Visualize(StaticState, StaticState.InitialDynamicState);
                    vis.SetInitData(Alg, ComputationLimit,
                                    StaticState.Map != null && StaticState.Map.OptimalSolutionCostSpecified ?
                                    StaticState.Map.OptimalSolutionCost :
                                    OptimalPathLength.ToDouble( ), File, Resultss);
                }
#else
                System.Console.WriteLine(StaticState.InitialDynamicState);
#endif
            }

            int StepNumber = 0;
            UncoverMap( );
            Stopwatch total = Stopwatch.StartNew( );
            Stopwatch step  = Stopwatch.StartNew( );
            foreach (var nextPath in
                     Algorithm.Compute(StaticState, StaticState.InitialDynamicState, Goal,
                                       Actions))
            {
                step.Stop( );
                total.Stop( );
                long CurrentUsage = Process.GetCurrentProcess( ).PrivateMemorySize64;
                if (CurrentUsage > MaxMemoryUsage)
                {
                    MaxMemoryUsage = CurrentUsage;
                }
                path = nextPath;
                if (path != null)
                {
                    foreach (var Action in path.Actions)
                    {
                        var oldState = StaticState.InitialDynamicState;
                        if (!Action.IsValidOn(StaticState.InitialDynamicState, StaticState, true))
                        {
                            throw new IllegalActionOnStateException(
                                      "Illegal Action Given By Algorithm");
                        }
                        StaticState.InitialDynamicState = Action.PerformOn(
                            StaticState.InitialDynamicState, StaticState).First( );
                        fullPath.Push(Action, oldState, StaticState.InitialDynamicState);
                        if (!Batch)
                        {
                            var U = StaticState.InitialDynamicState.FindUnit(0);
                            StaticState.Tiles[U.Y][U.X].Hits++;
#if OpenGl
                            vis.Visualize(StaticState, StaticState.InitialDynamicState);
                            vis.SetStepData((int)Algorithm.Generations, (int)Algorithm.Expansions,
                                            total.ElapsedTicks, fullPath.Cost.ToDouble( ) + numStops,
                                            ComputationTimes.Count != 0 ? ComputationTimes.Average( ): 0,
                                            MaxMemoryUsage, ComputationTimeMax,
                                            Expansions.Count != 0 ? Expansions.Average( ): 0);
#else
                            System.Console.WriteLine(StaticState.InitialDynamicState);
#endif
                        }
                        HandleChanges(Dynamic, StepNumber);
                    }
                }
                else
                {
                    numStops++;
                    HandleChanges(Dynamic, StepNumber);
#if OpenGl
                    if (!Batch)
                    {
                        vis.Visualize(StaticState, StaticState.InitialDynamicState);
                        (vis as OpenGLStateVisualizer).redraw( );
                        vis.SetStepData((int)Algorithm.Generations, (int)Algorithm.Expansions,
                                        total.ElapsedTicks, fullPath.Cost.ToDouble( ) + numStops,
                                        ComputationTimes.Count != 0 ? ComputationTimes.Average( ): 0,
                                        MaxMemoryUsage, ComputationTimeMax,
                                        Expansions.Count != 0 ? Expansions.Average( ): 0);
                    }
#endif
                }
                Expansions.Add(Algorithm.Expansions - LastExpansions);
                LastExpansions = Algorithm.Expansions;
                ComputationTimes.Add(step.ElapsedTicks);
                if (step.ElapsedTicks > ComputationTimeMax)
                {
                    ComputationTimeMax = step.ElapsedTicks;
                }
                if (Goal.IsSatisfiedBy(StaticState, StaticState.InitialDynamicState))
                {
                    break;
                }
                long t = refreshRate - step.ElapsedMilliseconds;
                if (t > 0)
                {
                    Thread.Sleep((int)t);
                }
                Metric maxPathLength = new Metric(computationLimitCeilingRatio *
                                                  (StaticState.Map != null && StaticState.Map.OptimalSolutionCostSpecified ?
                                                   StaticState.Map.OptimalSolutionCost :
                                                   OptimalPathLength.ToDouble( )));
                if (maxPathLength.Equals(Metric.Infinity) && fullPath.Cost + new Metric(numStops) >= maxPathLength)
                {
                    throw new MaxPathLengthExceded(
                              new Results(Alg, ComputationLimit, Algorithm.Generations,
                                          Algorithm.Expansions, total.ElapsedTicks, fullPath.Cost.ToDouble( ) + numStops,
                                          StaticState.Map != null && StaticState.Map.OptimalSolutionCostSpecified ?
                                          StaticState.Map.OptimalSolutionCost :
                                          OptimalPathLength.ToDouble( ), File, ComputationTimes.Average( ),
                                          MaxMemoryUsage, ComputationTimeMax, Expansions.Average( )));
                }
                StepNumber++;
                step.Reset( );
                step.Start( );
                total.Start( );
            }
            total.Stop( );
            if (!Batch)
            {
#if OpenGl
                if (vis != null)
                {
                    vis.Cleanup( );
                }
#else
                new GenericGridWorldPathVisualizer( ).Visualize(
                    Console.Out, fullPath, StaticState, StaticState.InitialDynamicState);
#endif
            }
            double AverageComputationTime = ComputationTimes.Average( );
            return(new Results(Alg, ComputationLimit, Algorithm.Generations,
                               Algorithm.Expansions, total.ElapsedTicks, fullPath.Cost.ToDouble( ) + numStops,
                               StaticState.Map != null && StaticState.Map.OptimalSolutionCostSpecified ?
                               StaticState.Map.OptimalSolutionCost :
                               OptimalPathLength.ToDouble( ), File, AverageComputationTime,
                               MaxMemoryUsage, ComputationTimeMax, Expansions.Average( )));
        }