Patent Description:
This application is generally related to improving the performance of computer programs running on computer systems that include multicore processors. More specifically, but not exclusively, the application relates to methods and apparatus for improving the performance of computer programs requiring significant computer resources in multicore computer systems.

Certain modem computer systems intended for consumer use have been designed to accommodate game applications by, for example, being configured with high-performance graphics processing units and substantial memory resources. However, game players desiring optimal game performance tend to want to minimize interferences in game performance caused by the execution of other programs. Simply put, users engaged in playing a game would prefer an uninterrupted experience and as much game performance as possible. However, game performance may often noticeably decrease when another program, such as, for example, an antivirus or a system update utility, begins to heavily utilize system resources.

Some, but not all optimizations can be achieved by manually configuring the operating system's settings. For example, some sophisticated users may engage in manually dedicating processor cores to the game process. This requires manually changing the affinity (i.e. on which processor cores the process is allowed to run ) of every running process, except for key operating system processes which should not have their affinity changed. This procedure should be repeated each time a game is started. Obviously, this can be a time-consuming operation and it requires knowledge of internal characteristics of computer operating systems which most users will not possess.

Another approach has been to install a dedicated computer program to dedicate one or more cores of a multicore processor to a game process. However, such dedicated programs
do not automatically detect when game applications are launched and tend to require users to start game applications through the application interface of the dedicated program. Moreover, such dedicated programs do not monitor the resource utilization of the game applications. As a result, a user may be required or incented to test or otherwise experiment with various features in order to determine their impact on performance.

Various antivirus vendors have "gaming modes" available in their products. Such gaming modes may be manually triggered or, alternatively, actuated when full screen operation is detected. Once a gaming mode has been triggered, antivirus protection may be turned off. This unfortunately leaves the computer system vulnerable to attack during the duration of game play and until the gaming mode is manually or automatically turned off. Moreover, existing antivirus gaming modes fail to dedicate processor cores to the game's process.

Other background processing programs including backup programs, file sync programs, cloud file sync programs (e.g., Dropbox, OneDrive, etc.), e-mail sync programs, may have the need for similar game modes.

<CIT> describes dynamic allocation of computing resources in remote gaming environments. Arrangements of this document monitor and dynamically allocate computing resources to game sessions running within a game service. A game service provides a remote gaming environments to which users connect over a wide area network, such as the internet. A game session runs a single instance of a game title. The game session runs the video game code responsible for creating the playing experience for the users. Various characteristics of the game session may be monitored and used to allocate computing resources. Usage of computing resources, such as central processing unit may be monitored directly. In another embodiment, the number of players connected to the game session is monitored and computing resources are allocated dynamically as the number of players increases or decreases.

Particular aspects of the invention are defined in the independent claims, with various optional embodiments set out in the dependent claims.

Disclosed herein are automated systems and methods for improving the performance of various applications, such as computer games, which tend to use relatively high levels of CPU and/or GPU resources.

In one aspect the disclosure relates to a method for improving performance of a game process in a computer system including a multicore processor having a plurality of cores. The method includes automatically detecting the game process that has begun executing on one or more of the plurality of cores. Following detection of the game process, other processes are automatically allocated to one of the plurality of cores different from the processor core or cores on which the game process is executing.

The disclosure is also directed to a method of allocating computer resources in a computer system including a multicore processor having a plurality of cores. The method includes monitoring usage of the computer resources by processes executing on the computer system. Based upon this monitoring, it may be determined that one of the processes is a high-utilization process consuming greater than a predefined threshold of the computer resources and corresponds to an application in an interactive state. The method further includes allocating one or more of the plurality of cores to the high-utilization process. Other of the plurality of cores may then be allocated to remaining ones of the processes, thereby
improving performance of the high-utilization process. Upon detecting that the application has transitioned from the interactive state, one or more of the plurality of cores are enabled to be allocated to other than the high-utilization process.

In another aspect the disclosure pertains to a method for improving performance of a game process in a computer system including a multicore processor having a plurality of cores. The method includes determining a number of the plurality of cores required to be utilized by the game process in order to meet one or more performance criteria. Upon this determination being made the game process may be allocated to the determined number of the plurality of cores. The method further includes parking one or more remaining cores in order to reduce heat generated by the processor, potentially allowing the system to increase the processor's frequency, and thereby improve performance of the game process.

The disclosure also relates to a system configured to optimize application performance. The computer system includes a multicore processor having a plurality of cores and a memory including a performance optimization module. The performance optimization module is configured to monitor usage of computer resources by processes executing on the computer system and determine that one of the processes is a high-utilization process in an interactive state that consumes greater than a predefined threshold of the computer resources. The module is further configured to allocate one or more of the plurality of cores to the high-utilization process and allocate other of the plurality of cores to remaining ones of the processes. This allocation improves performance of the high-utilization process. Upon detecting the application has transitioned from the interactive state, the module may enable the cores previously allocated to the high-utilization process to be allocated to other than the high-utilization process.

By dedicating computer resources to a high-utilization process such as a computer game, any decreases in performance due to interference from other processes can be minimized and potentially not detectable by the user. Because the detection is automated, less computer-experienced users can benefit from the disclosed optimizations without having to interact with the computer system.

The disclosed optimization approaches can also be applied to other programs that require high framerates such as, for example, programs enabling view of a <NUM> or High Definition video, other graphics applications or, more generally, other applications requiring high CPU usage. In implementations in which the execution of such other applications cannot be automatically detected in the manner described hereinafter, the disclosed performance optimizations may be initiated through user input.

The present application may be more fully appreciated in connection with the following detailed description taken in conjunction with the accompanying drawings, wherein:.

Various embodiments are described below with reference to the drawings, wherein like reference numerals are used to refer to like elements throughout. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of one or more embodiments. It may be evident, however, that such embodiment(s) can be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to facilitate describing one or more embodiments.

Disclosed herein are systems and methods capable of improving the performance of various applications such as computer games, streaming media or other applications characterized by high framerates, or applications which otherwise use relatively high levels of CPU or GPU resources. The disclosed methods have the effect of protecting such games and other high-utilization processes from interference caused by the execution of other programs, thus improving game performance and the user experience. Implementation of the teachings herein also enable antivirus and other security protection to remain operational without noticeably degrading the performance of such games or other high-CPU-usage programs.

In one aspect, disclosed herein is a system and method for automatically detecting when a computer game has started and for then optimizing the game process so as to improve the user experience. When the game stops running or becomes non-interactive, the computer system may be instructed to revert the modifications made to the operating system state in the optimizations phase. In one implementation, computer code involved in performing at least a portion of the disclosed method may be instantiated as a dedicated computer program. In other embodiments such computer code may be included within, for example, an antivirus program, endpoint protection program, security program, backup program, file sync program and the like.

As is discussed more fully below, in one embodiment the disclosed method for improving game performance includes a detection phase and an optimization phase. In one embodiment all running processes on a computer system are monitored during the detection phase. During this phase the CPU and GPU utilization of each process may be measured. In addition, each process may be examined to determine whether it is running in a fullscreen mode and whether the window associated with the process is active in the foreground. In addition, any graphics API's (e.g., DirectX, OpenGL) utilized by the process may be identified. Based upon these determinations and measurements, a decision is then made as to whether any of the running processes correspond to a game application. To the extent any processes corresponding to a game are detected, the resource usage of such processes may continue to be monitored in order to inform the selection of any optimization operations carried out during the optimization phase.

During optimization, various resource allocation operations may be performed in order to optimize performance of the game process. The operations may include, for example, dedicating computer resources to the game process. In a multicore computer system environment, such operations may include automatically reserving one or more CPU cores for the game process and restricting other processes to one or more other CPU core(s), or increasing the CPU priority, IO priority and/or network priority associated with the game process. In addition, other processes (e.g., antivirus or auto-backup processes) may be throttled back by lowering the CPU, IO and networking bandwidth allocation and priority associated with such other processes. In certain embodiments memory optimizations may also be performed. Other optimizations which may be implemented include, for example, switching to a higher performance power plan, disabling other software applications, or tuning of features such as hyper-threading or core parking which tend to have an impact on game performance.

In addition to game applications, the teachings herein may also be applied to enhance the performance of other programs or functions which require or involve high framerates or CPU usage (e.g., viewing a <NUM> or High Definition video or running a complex graphics application).

Referring now to <FIG>, a block diagram illustrating the principal components of a computer system <NUM> configured in accordance with teachings of the present disclosure is shown. Computer system <NUM> may be used to implement a desktop computer, a workstation, a laptop computer, or other type of data processing device. As shown, computer system <NUM> includes a multicore central processing unit ("CPU") <NUM> having a plurality of cores <NUM>, system memory <NUM>, disk storage <NUM>, data port(s) <NUM>, graphics processing unit (GPU) <NUM>, audio card <NUM> and network card(s) <NUM> connected by system bus <NUM>. System bus <NUM> may include a memory bus or memory controller, a peripheral bus, and a local bus, and may utilize any of a various known bus architectures. Network card(s) <NUM> may provide an Ethernet, Wi-Fi, GSM, Bluetooth or other wired, wireless, or cellular network interface for connecting computer system <NUM> to an external network, such as the Internet. Data port <NUM> may be any data port as is known in the art for interfacing with an external accessory using a data protocol such as RS-<NUM>, USB, or Firewire. Disk storage <NUM> may be a conventional read/write memory such as a magnetic disk drive, floppy disk drive, compact-disk read-only-memory (CD-ROM) drive, digital video disk (DVD) read or write drive, transistor-based memory or other computer-readable memory device as is known in the art for storing and retrieving data.

In one embodiment system memory <NUM> may include a read-only memory (ROM) <NUM> and random access memory (RAM) <NUM>. The ROM <NUM> generally stores a basic input/output system (BIOS), which contains foundational routines to convey information between components of computer system <NUM>. RAM <NUM> stores an operating system <NUM> (OS), such as, for example, Windows®, Linux or other type of OS. System memory <NUM> also stores applications and programs <NUM> currently executing as processes on the computer system <NUM>. These programs may include, for example, a game application <NUM> and an antivirus application <NUM> configured with a game optimization module <NUM> in the manner described herein.

CPU <NUM> communicates with a plurality of peripheral equipment. Additional peripheral equipment may include a display <NUM>, manual input device <NUM> and microphone <NUM>. Display <NUM> may be a visual display such as a liquid crystal display (LCD) screen, touch-sensitive screen, or other monitors as are known in the art for visually displaying images and text to a user. Manual input device <NUM> may be a conventional keyboard, keypad, mouse, trackball, or other input device as is known in the art for the manual input of data. Microphone <NUM> may be any suitable microphone as is known in the art for providing audio signals to CPU <NUM>. In addition, a speaker <NUM> may be attached for reproducing audio signals from CPU <NUM>. It is understood that microphone <NUM> and speaker <NUM> may include appropriate digital-to-analog and analog-to-digital conversion circuitry as appropriate.

Attention is now directed to <FIG>, which is a flowchart representative of a method <NUM> for improving game performance in accordance with the disclosure. In one embodiment the detection and optimization operations described with reference to <FIG> are performed by the game optimization module <NUM> of the antivirus application <NUM>. However, in other implementations these operations could be carried out by a standalone application program or by a module within a different application program (e.g., a security program).

As shown, the method <NUM> may include a detection phase <NUM> and an optimization phase <NUM>. During the detection phase, processes executed by the CPU <NUM> are typically monitored at a regular time intervals such as, for example, once per second (stage <NUM>). Such monitoring may include, for example, determining when the utilization of the GPU <NUM> by a process exceeds a given threshold (e.g., <NUM>% of the resources of the GPU <NUM> consumed by the process). When this occurs a check may be made to determine if the process is running in (i) a fullscreen mode, or (ii) a windowed mode in which the window for the process is in the foreground. If either condition (i) or (ii) exists and the GPU utilization by the process exceeds the given threshold, then in one embodiment it is determined that the process is a game (stage <NUM>). As an alternative to the implementation of stage <NUM> discussed above or as an additional check as part of such implementation, system hooks could be installed in the initialization functions of the most popular APIs for rendering 2D and 3D vector graphics currently in existence (e.g., DirectX and OpenGL) in order to detect processes causing such APIs to be initialized. Another method would be to simply enumerate the loaded libraries of each process and determinate if one of those libraries is related to one of the graphics APIs. It has been found that if a relatively high percentage (e.g., greater than <NUM>%) of the resources of the GPU <NUM> are utilized by a process and a graphics API such as DirectX or OpenGL has been loaded, there exists a high likelihood that the process is a game. The optimization phase <NUM> may begin once it has been determined during the detection phase <NUM> that one of the processes executed by the CPU <NUM> is a game.

It has been recognized that certain processes such as, for example, web browsers, Winword, Skype, Dropbox or other applications with a graphical user interface that loads one of the graphics APIs, may affect resource utilization in the computer system <NUM> in a similar manner to games. Such processes usually do not need high computer resource usage, so their optimization is not desirable. The threshold for GPU usage should be set high enough so that these kind of processes are not identified as games. However, false positives may theoretically occur. In these cases the game optimization module <NUM> may be configured so as to not automatically begin the optimization phase <NUM> with respect to such a process but to instead enable a user to select whether the optimization phase <NUM> should proceed. Such user selection could be made through, for example, settings associated with the game optimization module or through a "pop-up" menu or interface rendered via the display <NUM> at the conclusion of stage <NUM>.

The optimization phase <NUM> may begin by monitoring the utilization of the CPU <NUM> by the threads of the game process in order to determine the number of threads of the game associated with high utilization of the CPU <NUM> (stage <NUM>). The thread information collected may be useful in subsequently determining which and how many CPU cores <NUM> should be allocated to the game and which CPU cores <NUM> should be left for other processes. Next, in one embodiment, system-wide optimizations intended to enhance performance of the detected game process (game. exe) are performed (stage <NUM>). These optimizations may include, for example, switching to a customized higher performance power plan, launching a user configured program with parameters, stopping or freezing various unneeded processes, and/or delaying certain scheduled tasks (stage <NUM>). In one embodiment the customized higher performance power plan may disable core parking (e.g., on all cores <NUM> or on non-hyper-threaded cores <NUM>), set minimum processor state to <NUM>%, set processor performance boost policy to <NUM>% (if available), set the PCI express link state power management to off, and disable turning off disk storage <NUM>. The user-configured program could be, for example, an overclocking program for the GPU <NUM> or CPU <NUM>.

Referring again to <FIG>, the game optimization module <NUM> will typically be configured to perform a number of operations designed to optimize execution of the detected game process (stage <NUM>). For example, if hyper-threading is enabled then the game optimization module <NUM> may set the process affinity for the detected game process to certain non-hyper-threaded cores <NUM>; that is, the game optimization module may cause certain non-hyper-threaded cores to be allocated to the detected game process.

<FIG> illustrates one manner in which process affinity of the game process may be set in a system <NUM>' including a set of eight (<NUM>) processor cores <NUM> when hyper-threading is present. As shown, in the example of <FIG> all non-hyper-threaded CPU cores <NUM> except for core <NUM><NUM> and core <NUM><NUM> are allocated to the detected game process (game. In this approach CPU core <NUM><NUM> and core <NUM><NUM> are used for other running processes. In addition, the game optimization module <NUM> may park the hyper-threaded CPU cores <NUM><NUM>, <NUM><NUM>, and <NUM><NUM> in order to reduce the heat generated by the CPU <NUM> during execution of the detected game process.

Turning now to <FIG>, there is shown an exemplary setting of process affinity for the detected game process in a system <NUM>'' including a set of four (<NUM>) CPU cores <NUM> when hyper-threading is not present. In this case the process affinity is set to processor cores <NUM><NUM>, <NUM><NUM>, and <NUM><NUM>, with CPU core <NUM><NUM> being used for the other running processes.

As part of the game process optimization procedure (stage <NUM>), the CPU priority and disk access (IO) priority of the game process will generally be increased to the highest available level that doesn't result in system instability (e.g., above normal or high priority). Networking priority of the game process can also be increased. In one embodiment, key processes of the operating system <NUM> (e.g., smss. exe or csrss. exe in the case of Windows) will not have their affinity modified, since doing so could potentially result in interference with the game's performance.

Referring again to <FIG>, the process affinity of other running processes may be set to those of the CPU cores <NUM> not allocated to the game process in order to minimize the potential for interference with the game process (stage <NUM>). In the example of <FIG>, the process affinity of other processes is set to CPU core <NUM><NUM>. The CPU and IO priorities of these other running processes may also optionally be lowered as part of stage <NUM>.

The game optimization module <NUM> will generally be configured to continuously monitor the system <NUM> for any new processes and to identify any game processes that have ended or have been minimized (e.g., taken out of fullscreen mode or the foreground) (stage <NUM>). In the case of new non-game processes, their process affinity will be set to be the same as that of any other running non-game processes; that is, any new non-game processes will typically be allocated to CPU cores <NUM> not allocated to a game process. The network, I/O and other priorities of any new process may also be lowered for the duration of any detected game process. If a game is minimized (stage <NUM>), it is likely the case that a user of the game desires to interact with other programs. Accordingly, in that case some or all system optimizations may be reverted to a default state so that multitasking performs better and the process affinities of other processes may be reset to their normal or default condition (stage <NUM>). In one embodiment, monitoring of minimized game processes continues to occur after such reversion of system optimizations and other processes to default or otherwise normal operating conditions; that is, minimized game processes are monitored to determine if they again are brought to the foreground (stage <NUM>). If any minimized game processes are determined to have been subsequently brought to the foreground (stage <NUM>), then optimizations previously applied may again become active (stage <NUM>).

At some point the game optimization module <NUM> will generally determine that a game process has ended (stage <NUM>). At this point all processes will typically have their respective process affinities and priorities restored to initial values and the active power plan will be switched to the power plan in effect before the game started (stage <NUM>).

<FIG> and <FIG> are screen shots of exemplary user interfaces through which parameters of the optimizations made by the game optimization module <NUM> may be adjusted. Specifically, <FIG> is a screen shot of a user interface <NUM> generated upon selection of a Power Options item in the Control Panel that permits a user to specify settings of the customized higher performance power plan <NUM> that may be invoked pursuant to stage <NUM>. <FIG> is a screen shot of a user interface <NUM> generated by the antivirus application <NUM> that permits a user to specify which of various optimizations are performed once a game process has been detected by the game optimization module <NUM>. For example, a user may indicate whether, in the event a game process is detected, the computer system should switch to the customized higher performance power plan, restrict other non-game processes to only one CPU core <NUM>, increase the disk access priority of the detected game process, and/or increase the CPU priority of the detected game process.

A system and method for dynamically allocating resources to a game process that offers advantages relative to prior approaches to improving game performance has been described. Embodiments of the disclosed solution automatically detect game processes and monitor their resource utilization so as to enable the best of several possible optimization schemes to be employed. The disclosed approach advantageously minimizes the necessity for user interaction with the game optimization module or program, thereby enabling even users with minimal knowledge of computer systems to obtain performance benefits. This contrasts with prior approaches in which a user may need to test or otherwise experiment with various features in order to assess their impact on game performance. Prior approaches also fail to utilize other optimizations described herein such as, for example, switching to a higher performance power plan, disabling or tuning core parking, increasing game IO and network priority and decreasing other processes priorities.

Embodiments of the disclosed dynamic resource allocation method may include a combination of: (i) an antivirus, endpoint protection or security program; (ii) automatic detection of start and stop of processes involved in game playing, HD/<NUM> video playing, or similar activities requiring high GPU and CPU utilization; and/or (iii) automatic allocation of all other processes to a single computing core, thereby allowing all other cores to be used for (ii). This automatic allocation may include, for example, allocating the protection program to the single computing core and lowering its resource utilization. An advantage of this approach is that non-game processes, such as security or antivirus processes, are permitted to continue to run, even if at a somewhat slower rate.

If more than one computing core is only minimally utilized at the time of automatic allocation of processes to computing cores, then non-game processes may be allocated across such minimally-utilized computing cores to improve the performance of the non-game processes. Alternatively, the minimally-utilized computing cores could be parked to reduce heat generated by the CPU <NUM> and thereby potentially improve performance of the game process.

The disclosed solution offers optimization choices not believed to be available through other game enhancement approaches. Such potential optimizations may include, for example, like switching to a higher performance power plan, disabling or tuning core parking, increasing game IO and network priority while decreasing the CPU, IO and network priority of other processes, custom program(s) launching after a game is detected, stopping or freezing unneeded processes. Moreover, it is believed that detection of game processes by, for example, monitoring GPU utilization in combination with detection of the graphics APIs (e.g., DirectX and OpenGL) actually utilized is a novel approach to improving game performance. This game process detection scheme in combination with the automatic computer resources allocation techniques described herein are also believed to be unique. In addition, the technique of monitoring the CPU utilization of a game process to determine the number of processing cores the game needs to perform optimally and then parking certain unneeded cores to reduce heat generated by a CPU is also believed to a novel method of improving game performance.

Although the disclosed game process detection and optimization techniques have been described as operating within the context of an antivirus, endpoint protection or security program, the disclosed techniques may be employed to enhance game process performance in the presence of other processes which may impair game performance through high utilization of CPU resources. Such other processes may include, for example, background monitoring programs such as backup applications, automatic clean up tools, performance tuning tools, and disk optimization tools. More generally, the teachings herein may be applied to the case in which one or more running programs (program A) may potentially interfere with the execution of another program of interest (program B). For example, the running processes corresponding to program A may be initially monitored. When it is automatically detected that program B begins to use the same processing core on which program A resides, program A is automatically move to an different, available processing core in order to improve the performance of program B.

In some configurations, the apparatus or system includes means for performing various functions as described herein. In one aspect, the aforementioned means may be a module including a processor or processors and associated memory in which embodiments of the invention reside, such as are shown in the preceding drawings and which are configured to perform the functions recited by the aforementioned means. This may be, for example, modules or apparatus residing in client devices, host server systems, and/or other network devices such as are shown and/or described herein. In another aspect, the aforementioned means may be a module or apparatus configured to perform the functions recited by the aforementioned means.

In one or more exemplary embodiments, the functions, methods and processes described may be implemented in hardware, software, firmware, or any combination thereof. By way of example, and not limitation, such computer-readable media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer.

As used herein, computer program products comprising computer-readable media including all forms of computer-readable medium except, to the extent that such media is deemed to be non-statutory, transitory propagating signals.

It is understood that the specific order or hierarchy of steps or stages in the processes and methods disclosed are examples of exemplary approaches. Based upon design preferences, it is understood that the specific order or hierarchy of steps in the processes may be rearranged while remaining within the scope of the present disclosure. The accompanying method claims present elements of the various steps in a sample order, and are not meant to be limited to the specific order or hierarchy presented.

Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both.

The steps or stages of a method, process or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. An exemplary storage medium is coupled to the processor such the processor can read information from, and write information to, the storage medium.

The previous description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the present disclosure. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments. Thus, the present disclosure is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

The disclosure is not intended to be limited to the aspects shown herein, but is to be accorded the full scope consistent with the specification and drawings, wherein reference to an element in the singular is not intended to mean "one and only one" unless specifically so stated, but rather "one or more. As an example, "at least one of: a, b, or c" is intended to cover: a; b; c; a and b; a and c; b and c; and a, b and c.

Claim 1:
A method of allocating computer resources in a computer system including a multicore processor having a plurality of cores, the method comprising:
monitoring usage of the computer resources by a plurality of processes executing on the computer system;
determining, based upon the monitoring, that one of the plurality of processes executing on the computer system is a game application, wherein the determining that the process is a game application is based on a finding that the process:
consumes greater than a predefined threshold of the computer resources; and
is in an interactive state corresponding to at least one of (i) operation of the process in fullscreen mode, and (ii) operation of the process in windowed mode wherein a window of the application is a foreground window;
modifying an operating state of the computer system from a default state to an optimized state in which the allocation of computer resources to the game application are increased, thereby improving performance of the game application;
detecting that the game application has transitioned from the interactive state to a non-interactive state, wherein the detecting includes determining that a user interface window of the game application has been minimized; and
based upon the detected transition to the non-interactive state, reverting the operating state of the computer system from the optimized state to the default state.