private bool CheckForNeedButton(ProcessPriorityClass priority)
 {
     if (priority == ProcessPriorityClass.Normal)
     {
         radioButton1.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.AboveNormal)
     {
         radioButton2.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.BelowNormal)
     {
         radioButton3.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.High)
     {
         radioButton4.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.Idle)
     {
         radioButton5.Checked = true;
         return true;
     }
     else if (priority == ProcessPriorityClass.RealTime)
     {
         radioButton6.Checked = true;
         return true;
     }
     return false;
 }

 public ConsoleProcess()
 {
     BufferSizeStdout = 4096;
     BufferSizeStderr = 4096;
     ModeStderr = CommunicationMode.Line;
     ModeStdout = CommunicationMode.Line;
     PriorityClass = ProcessPriorityClass.Normal;
 }

        public virtual void SetPriority(int processId, ProcessPriorityClass priority)
        {
            var process = Process.GetProcessById(processId);

            Logger.Info("Updating [{0}] process priority from {1} to {2}",
                        process.ProcessName,
                        process.PriorityClass,
                        priority);

            process.PriorityClass = priority;
        }

        public void Initialize()
        {
            this.CachedProcessPriorityClass = Process.GetCurrentProcess().PriorityClass;
            this.CachedThreadPriority = Thread.CurrentThread.Priority;
            
            Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
            Thread.CurrentThread.Priority = ThreadPriority.Highest;

            this.IsCachedStatus = true;

            this.Time(1, () => { });
        }

        private void ChangePriority(ProcessPriorityClass priority)
        {
            cbxPriority.SelectedValue = priority;

            for (var i = 0; i < tsmiPriority.DropDownItems.Count; i++)
            {
                var item = (ToolStripMenuItem)tsmiPriority.DropDownItems[i];
                item.Checked = (int)item.Tag == (int)priority;
            }

            processor.Priority = priority;
        }

#pragma warning disable 0618
		/// <summary>
		/// Initializes a new instance of the <see cref="HighPerformance"/> class.
		/// </summary>
		internal HighPerformance() {
			////if (!WaitForQuietCpu()) {
			////    Assert.Inconclusive("Timed out waiting for a quiet CPU in which to perform perf tests.");
			////}

			this.originalLoggerThreshold = LogManager.GetLoggerRepository().Threshold;
			LogManager.GetLoggerRepository().Threshold = LogManager.GetLoggerRepository().LevelMap["OFF"];
			this.powerSetting = new PowerManagment.PowerSetting(PowerManagment.PowerProfiles.HighPerformance);
			this.originalProcessPriority = Process.GetCurrentProcess().PriorityClass;
			Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
			Thread.CurrentThread.Priority = ThreadPriority.Highest;
			SpinCpu();
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="ProcessInfo"/> class.
 /// </summary>
 /// <param name="filename">The filename.</param>
 /// <param name="arguments">The arguments.</param>
 /// <param name="workingDirectory">The working directory.</param>
 /// <param name="priority">The priority.</param>
 /// <param name="successExitCodes">The success exit codes.</param>
 public ProcessInfo(string filename, SecureArguments arguments, string workingDirectory, ProcessPriorityClass priority, int[] successExitCodes)
 {
     this.arguments = arguments;
     this.priority = priority;
     startInfo.FileName = filename.StripQuotes();
     startInfo.Arguments = arguments == null ? null : arguments.ToString(SecureDataMode.Private);
     startInfo.WorkingDirectory = workingDirectory.StripQuotes();
     startInfo.UseShellExecute = false;
     startInfo.CreateNoWindow = true;
     startInfo.RedirectStandardOutput = true;
     startInfo.RedirectStandardError = true;
     startInfo.RedirectStandardInput = false;
     this.successExitCodes = successExitCodes ?? new[] { 0 };
 }

 /// <summary>
 /// Executes the <paramref name="executable"/> and waits a maximum time of <paramref name="maxWaitMs"/> for completion. If the process doesn't end in 
 /// this time, it gets aborted. This method tries to impersonate the interactive user and run the process under its identity.
 /// </summary>
 /// <param name="executable">Program to execute</param>
 /// <param name="arguments">Program arguments</param>
 /// <param name="priorityClass">Process priority</param>
 /// <param name="maxWaitMs">Maximum time to wait for completion</param>
 /// <returns><c>true</c> if process was executed and finished correctly</returns>
 public static bool TryExecute_Impersonated(string executable, string arguments, ProcessPriorityClass priorityClass = ProcessPriorityClass.Normal, int maxWaitMs = INFINITE)
 {
   IntPtr userToken;
   if (!ImpersonationHelper.GetTokenByProcess(out userToken, true))
     return false;
   try
   {
     string unused;
     return TryExecute_Impersonated(executable, arguments, userToken, false, out unused, priorityClass, maxWaitMs);
   }
   finally
   {
     ImpersonationHelper.SafeCloseHandle(userToken);
   }
 }

 /// <summary>
 /// Executes the <paramref name="executable"/> and waits a maximum time of <paramref name="maxWaitMs"/> for completion and returns the contents of
 /// <see cref="Process.StandardOutput"/>. If the process doesn't end in this time, it gets aborted.
 /// </summary>
 /// <param name="executable">Program to execute</param>
 /// <param name="arguments">Program arguments</param>
 /// <param name="result">Returns the contents of standard output</param>
 /// <param name="priorityClass">Process priority</param>
 /// <param name="maxWaitMs">Maximum time to wait for completion</param>
 /// <returns></returns>
 public static bool TryExecuteReadString(string executable, string arguments, out string result, ProcessPriorityClass priorityClass = ProcessPriorityClass.Normal, int maxWaitMs = 1000)
 {
   using (System.Diagnostics.Process process = new System.Diagnostics.Process { StartInfo = new ProcessStartInfo(executable, arguments) { UseShellExecute = false, CreateNoWindow = true, RedirectStandardOutput = true } })
   {
     process.Start();
     process.PriorityClass = priorityClass;
     using (process.StandardOutput)
     {
       result = process.StandardOutput.ReadToEnd();
       if (process.WaitForExit(maxWaitMs))
         return process.ExitCode == 0;
     }
     if (!process.HasExited)
       process.Kill();
   }
   return false;
 }

        public ClientConnection(string hostName, string ipAddress, int instance, ProcessPriorityClass priority, int bitSize)
        {
            IsOnline = true;
            Jobs = new List<Job>();
            PriorityJobs = new List<Job>();
            CurrentJob = "";
            ActiveHours = "YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY";
            Id = (_nextClientId++);
            HostName = hostName;
            IPAddress = ipAddress;
            Instance = instance;
            Priority = priority;
            BitSize = bitSize;
            _lastCall.Reset();
            _lastCall.Start();

            RestoreSettings();
        }

        public void Run(ProcessEx process, ProcessPriorityClass priority)
        {
            if (this.Status.InUse)
            throw new InvalidOperationException("Current core is running another process");

              if (process == null)
            throw new ArgumentNullException("Process can not be null");

              this.Process = process;
              this.Process.ExecutingCore = this;

              //bind event
              this.Process.Exited += Process_Exited;

              this.Process.Start();
              this.Process.Status = ProcessExecutionStatus.Running;
              this.Process.PriorityClass = priority;
              this.Status.InUse = true;

              //TODO set affinity
              this.Process.ProcessorAffinity = (IntPtr) (int) Math.Pow(2, this.Status.Index);
        }

        public void RegistSchedule(string serviceName,ProcessPriorityClass Priority,string FilePath,string args)
        {
            using (TaskService task= new TaskService())
            {
                string SchedulerName= "GISHitpanDBManager"+Guid.NewGuid().ToString();
                using(TaskDefinition def = task.NewTask())
                {
                    //일반
                    def.Principal.DisplayName = serviceName;
                    def.Principal.UserId=string.Format("{0}\\{1}",Environment.UserDomainName,Environment.UserName);
                    def.Principal.LogonType=TaskLogonType.InteractiveToken;
                    def.Principal.RunLevel=TaskRunLevel.Highest;
                    def.Triggers.Add( new LogonTrigger());
                    //조건
                    def.Settings.MultipleInstances=TaskInstancesPolicy.IgnoreNew;
                    def.Settings.DisallowStartIfOnBatteries=false;
                    def.Settings.StopIfGoingOnBatteries=false;
                    def.Settings.AllowHardTerminate=false;
                    def.Settings.StartWhenAvailable=true;
                    def.Settings.RunOnlyIfNetworkAvailable=false;
                    def.Settings.IdleSettings.StopOnIdleEnd=false;
                    def.Settings.IdleSettings.RestartOnIdle=false;
                    //설정
                    def.Settings.AllowDemandStart=false;
                    def.Settings.Enabled=true;
                    def.Settings.Hidden=false;
                    def.Settings.RunOnlyIfIdle=false;
                    def.Settings.ExecutionTimeLimit=TimeSpan.Zero;
                    def.Settings.Priority = Priority;
                    //동작
                    def.Actions.Add(FilePath, args);
                    //등록
                    task.RootFolder.RegisterTaskDefinition(SchedulerName,def);
                }

            }
        }

 /// <summary>
 /// Queues the process.
 /// </summary>
 /// <param name="process">The process to enqueue.</param>
 /// <param name="prc">process priority.</param>
 public void QueueProcess(ProcessEx process, ProcessPriorityClass prc)
 {
     lock (_queueLock)
       {
     this._processQueue.Enqueue(new KeyValuePair<ProcessEx, ProcessPriorityClass>(process, prc));
     process.Status = ProcessExecutionStatus.Queued;
       }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ProcessInfo" /> class.	
 /// </summary>
 /// <param name="filename">The filename.</param>
 /// <param name="arguments">The arguments.</param>
 /// <param name="workingDirectory">The working directory.</param>
 /// <param name="priority">The priority.</param>
 /// <remarks></remarks>
 public ProcessInfo(string filename, PrivateArguments arguments, string workingDirectory, ProcessPriorityClass priority) :
     this(filename, arguments, workingDirectory, priority, null){}

 private void SetProcessPriority(ProcessPriorityClass priority)
 {
     try
     {
         using (var phandle = new ProcessHandle(processSelectedPid, ProcessAccess.SetInformation))
             phandle.SetPriorityClass(priority);
     }
     catch (Exception ex)
     {
         PhUtils.ShowException("Unable to set process priority", ex);
     }
 }

 public SetPriorityJob(ProcessPriorityClass priority)
 {
     _priority = priority;
 }

 private ProcessInfo NewProcessInfo(string args, IIntegrationResult result, ProcessPriorityClass priority, int[] successExitCodes)
 {
     Log.Info(string.Concat("[Git] Calling git ", args));
     var processInfo = new ProcessInfo(Executable, args, BaseWorkingDirectory(result), priority,
                                               successExitCodes);
     //processInfo.StreamEncoding = Encoding.UTF8;
     return processInfo;
 }

        /// <summary>
        /// Starts spring game
        /// </summary>
        /// <param name="client">tasclient to get current battle from</param>
        /// <param name="priority">spring process priority</param>
        /// <param name="affinity">spring process cpu affinity</param>
        /// <param name="scriptOverride">if set, overrides generated script with supplied one</param>
        /// <param name="userName">lobby user name - used to submit score</param>
        /// <param name="passwordHash">lobby password hash - used to submit score</param>
        /// <returns>generates script</returns>
        public string StartGame(TasClient client, ProcessPriorityClass? priority, int? affinity, string scriptOverride, bool useSafeMode = false, bool useMultithreaded=false, BattleContext contextOverride = null, Battle battleOverride = null) {
            if (!File.Exists(paths.Executable) && !File.Exists(paths.DedicatedServer)) throw new ApplicationException(string.Format("Spring or dedicated server executable not found: {0}, {1}", paths.Executable, paths.DedicatedServer));

            this.client = client;
            wasKilled = false;

            if (!IsRunning) {
                gameEndedOk = false;
                IsBattleOver = false;
                lobbyUserName = client.UserName;
                lobbyPassword = client.UserPassword;
                battleResult = new BattleResult();

                talker = new Talker();
                talker.SpringEvent += talker_SpringEvent;
                var battle = battleOverride ?? client.MyBattle;
                isHosting = client != null && battle != null && battle.Founder.Name == client.MyUser.Name;

                if (isHosting) scriptPath = Utils.MakePath(paths.WritableDirectory, "script_" + battle.Founder + ".txt").Replace('\\', '/');
                else scriptPath = Utils.MakePath(paths.WritableDirectory, "script.txt").Replace('\\', '/');

                statsPlayers.Clear();
                statsData.Clear();
                StartContext = null;

                string script;
                if (!string.IsNullOrEmpty(scriptOverride)) {
                    battleResult.IsMission = true;
                    isHosting = false;
                    script = scriptOverride;
                }
                else {
                    List<UserBattleStatus> players;
                    battleGuid = Guid.NewGuid();
                    var service = GlobalConst.GetSpringieService();
                    SpringBattleStartSetup startSetup = null;
                    if (isHosting && GlobalConst.IsZkMod(battle.ModName)) {
                        try {
                            StartContext = contextOverride ?? battle.GetContext();
                            startSetup = service.GetSpringBattleStartSetup(StartContext);
                            if (startSetup.BalanceTeamsResult != null)
                            {
                                StartContext.Players = startSetup.BalanceTeamsResult.Players;
                                StartContext.Bots = startSetup.BalanceTeamsResult.Bots;
                            }
                            connectedPlayers.Clear();
                            foreach (var p in StartContext.Players)
                            {
                                p.IsIngame = true;
                            }
                        } catch (Exception ex) {
                            Trace.TraceError("Error getting start setup: {0}", ex);
                        }
                    }

                    script = battle.GenerateScript(out players, client.MyUser, talker.LoopbackPort, battleGuid.ToString(), startSetup);
                    battleResult.IsMission = battle.IsMission;
                    battleResult.IsBots = battle.Bots.Any();
                    battleResult.Title = battle.Title;
                    battleResult.Mod = battle.ModName;
                    battleResult.Map = battle.MapName;
                    battleResult.EngineVersion = paths.SpringVersion;
                    talker.SetPlayers(players);
                    statsPlayers = players.ToDictionary(x => x.Name,
                                                        x => new BattlePlayerResult
                                                                 {
                                                                     LobbyID = x.LobbyUser.AccountID,
                                                                     AllyNumber = x.AllyNumber,
                                                                     CommanderType = null,
                                                                     // todo commandertype
                                                                     IsSpectator = x.IsSpectator,
                                                                     IsVictoryTeam = false,
                                                                 });
                }
                if (isHosting) timer.Start();

                File.WriteAllText(scriptPath, script);

                LogLines = new StringBuilder();

                var optirun = Environment.GetEnvironmentVariable("OPTIRUN");

                process = new Process();
                process.StartInfo.CreateNoWindow = true;
                List<string> arg = new List<string>();


                if (string.IsNullOrEmpty(optirun))
                {
                    if (UseDedicatedServer)
//.........这里部分代码省略.........

 /// <summary>
 /// Executes the <paramref name="executable"/> and waits a maximum time of <paramref name="maxWaitMs"/> for completion and returns the contents of
 /// <see cref="Process.StandardOutput"/>. If the process doesn't end in this time, it gets aborted.
 /// </summary>
 /// <param name="executable">Program to execute</param>
 /// <param name="arguments">Program arguments</param>
 /// <param name="result">Returns the contents of standard output</param>
 /// <param name="priorityClass">Process priority</param>
 /// <param name="maxWaitMs">Maximum time to wait for completion</param>
 /// <returns></returns>
 public static bool TryExecuteReadString_AutoImpersonate(string executable, string arguments, out string result, ProcessPriorityClass priorityClass = ProcessPriorityClass.Normal, int maxWaitMs = 1000)
 {
   return IsImpersonated ?
     TryExecuteReadString_Impersonated(executable, arguments, out result, priorityClass, maxWaitMs) :
     TryExecuteReadString(executable, arguments, out result, priorityClass, maxWaitMs);
 }

 /// <summary>
 /// Executes the <paramref name="executable"/> and waits a maximum time of <paramref name="maxWaitMs"/> for completion. If the process doesn't end in 
 /// this time, it gets aborted.
 /// </summary>
 /// <param name="executable">Program to execute</param>
 /// <param name="arguments">Program arguments</param>
 /// <param name="priorityClass">Process priority</param>
 /// <param name="maxWaitMs">Maximum time to wait for completion</param>
 /// <returns><c>true</c> if process was executed and finished correctly</returns>
 public static bool TryExecute(string executable, string arguments, ProcessPriorityClass priorityClass = ProcessPriorityClass.Normal, int maxWaitMs = INFINITE)
 {
   string unused;
   return TryExecute(executable, arguments, false, out unused, priorityClass, maxWaitMs);
 }