Memory-Efficient Software Patching for Updating Applications on a Computing Device

Abstract

To provide a method of performing memory efficient patching for computing devices, a server computing device, and a memory medium.SOLUTION: In a computing system 100, a memory of an application provider server stores a plurality of first assets that form an unpatched application and a plurality of second assets that form a patched application. A processor acquires a patch on the basis of differences between a single first virtual asset and a single second virtual asset. The patch identifies how to update the single first virtual asset to obtain the single second virtual asset. The processor also segments the patch into a plurality of segments and outputs to a computing device a single segment from the plurality of segments for individual application by the computing device.SELECTED DRAWING: Figure 1

Description

Background Art

[0001] Background Software developers may provide one or more application update information or “patches” to improve the functionality of an application. A patch may include one or more application elements such as compiled source code (which may be executable code or various abstractions thereof, such as bytecode), textures, images, videos, video files, audio files, or other resources referenced by the executable code. In some distributed environments, a user computing device (e.g., a smartphone) may use an application store application (sometimes referred to as an “application store”) to obtain and install patches, and these patches are provided by a remote server computing system that supports the operation of the application store.

[0002] In some instances, when a user selects an existing installed application on a user computing device for updating, the user computing device may download a so-called "patch" that includes all application update information. Thus, the expression "patch" may mean the difference between the compiled source code and the latest version of the compiled source code. The user computing device may then create a copy of the compiled source code of the installed application (which may be an executable binary file) and install the patch on the copy of the compiled source code to obtain the latest compiled source code. Such an application update process may require the user computing device to have sufficient storage space to store the compiled source code of the installed application, the patch (which may require decompression, perhaps twice, since the compressed version of the patch may result in another decompressed version of the patch), and the latest compiled source code. Summary of the Invention

[0003] Summary Generally, the techniques of the present disclosure may enable a user computing device to install patches more efficiently (in terms of memory consumption). The user computing device may obtain a patch from a server computing device (sometimes referred to as a "server"). The server may generate this patch as the difference between an unpatched application and a patched application, and the patch may define a series of commands indicating whether to delete, copy, or write data for creating the patched application from the unpatched application. The patch may include additional data to be written to create the patched application. The server may segment this patch into one or more segments with a total number of bytes less than the total number of bytes of the entire patch, and each of these segments may be individually installable on the unpatched application. The server may send each segment of the one or more segments individually to the user computing device.

[0004] The user computing device may receive the patch in the form of each individual segment of the one or more segments, and then install each individual segment one at a time. After installing each segment, the user computing device may request the next segment of the one or more segments, and repeat this process until the entire patch is systematically applied to the unpatched application. Also, the server may send additional metadata indicating when the user computing device may delete various assets of the unpatched application, whereby additional memory may be freed (or, in other words, available memory may be increased) by deleting a portion of the unpatched application, so that the user computing device may consume even less memory during the application of the patch.

[0005] Therefore, the described technology can improve the operation of user computing devices and computing systems that include user computing devices and servers. By receiving and installing patches in segments, the described technology can reduce the amount of storage required on a user computing device to install the patches and improve the performance of the user computing device (patching can improve the processing throughput during patch application and reduce bandwidth utilization, including memory bandwidth utilization, by being extracted over time). Also, by enabling the deletion of a portion of an unpatched application during the application of a segment of the patch to the unpatched application, memory utilization can be further reduced, thereby improving the performance of the user computing device.

[0006] In one example, various aspects of these techniques are directed to a method that includes one or more processors virtualizing a first plurality of assets that form an unpatched application to obtain a single first virtual asset, the one or more processors obtaining a single second virtual asset that represents a second plurality of assets that form a patched application, the one or more processors obtaining a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset used to update the single first virtual asset, the method further including the one or more processors segmenting the patch into a plurality of segments and the one or more processors outputting a single segment from the plurality of segments to the user computing device for individual installation on the unpatched application by the user computing device.

[0007] In another example, various aspects of these techniques are directed to a server computing device, the server computing device comprising a memory configured to store a first plurality of assets that form an unpatched application and a second plurality of assets that form a patched application, and one or more processors, the one or more processors being configured to virtualize the first plurality of assets to obtain a single first virtual asset, to obtain a single second virtual asset representing a second plurality of assets that form a patched application, to obtain a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset used to update the single first virtual asset, the one or more processors further being configured to segment the patch into a plurality of segments and output a single segment from the plurality of segments to the user computing device for individual installation on the unpatched application on the user computing device. The user computing device is configured to output.

[0008] In another example, various aspects of these techniques are directed to a non-transitory computer-readable storage medium storing instructions that, when executed, cause one or more processors to virtualize a first plurality of assets that form an unpatched application to obtain a single first virtual asset, to obtain a single second virtual asset representing a second plurality of assets that form a patched application, to obtain a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset used to update the single first virtual assetincluding 、When executed, the command further causes the one or more processors to segment the patch into a plurality of segments and output a single segment from the plurality of segments to the user computing device for individual installation on the unpatched application by the user computing device.

[0009] In another example, various aspects of these techniques are directed to a method that includes a step in which one or more processors of a user computing device obtain a single segment of a plurality of segments from a server computing device, where the plurality of segments represent a patch, and the patch identifies how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, and includes a portion of the second virtualized asset used to update the single first virtualized asset. The method further includes steps in which the one or more processors virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset, and the one or more processors apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, where the single second virtual asset includes a second plurality of assets that form the patched application.

[0010] In another example, various aspects of these techniques are directed to a user computing device, the user computing device comprising a memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing the patched application, the patches including a portion of the second virtualized asset used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors configured to virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset, apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets forming the patched application.

[0011] In another example, various aspects of these techniques are directed to a non-transitory computer-readable storage medium storing instructions that, when executed, cause one or more processors of a user computing device to obtain a single segment of a plurality of segments from a server computing device, the plurality of segments represents a patch, and the patch identifies how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, includes a portion of the second virtualized asset used to update the single first virtualized asset, and the instruction, when executed, further causes one or more processors of the user computing device to virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset, apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, and the single second virtual asset includes a second plurality of assets that form the patched application.

[0012] In another example, various aspects of these techniques are directed to a method that includes steps of one or more processors virtualizing a first plurality of assets that form an unpatched application to obtain a single first virtual asset, one or more processors virtualizing a second plurality of assets that form a patched application to obtain a single second virtual asset, and one or more processors obtaining a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset used to update the single first virtual asset, the method further including steps of one or more processors generating metadata indicating when the user computing device can delete a portion of the single first virtual asset while obtaining the patch, and one or more processors outputting the patch and the metadata to the user computing device.

[0013] In another example, various aspects of these techniques are directed to a server computing device, the server computing device comprising a memory configured to store a first plurality of assets that form unpatched applications and a second plurality of assets that form patched applications, and one or more processors, the one or more processors being configured to virtualize the first plurality of assets to obtain a single first virtual asset, virtualize the second plurality of assets to obtain a single second virtual asset, obtain a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset used to update the single first virtual asset, the one or more processors further being configured to generate metadata indicating when a user computing device can delete a portion of the single first virtual asset while obtaining the patch, and output the patch and the metadata to the user computing device.

[0014] In another example, various aspects of these techniques are directed to a non-transitory computer-readable storage medium storing instructions that, when executed, cause one or more processors to virtualize a first plurality of assets that form unpatched applications to obtain a single first virtual asset, virtualize a plurality of assets that form patched applications to obtain a single second virtual asset, obtain a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset used to update the single first virtual asset includingWhen executed, the command further causes one or more of the processors to generate metadata indicating when the user computing device can delete a portion of the single first virtual asset while obtaining the patch, and output the patch and the metadata to the user computing device.

[0015] In another example, various aspects of these techniques are directed to a method that includes steps in which one or more processors of a user computing device obtain a patch from a server computing device, the patch identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, the single second virtualized asset including a portion of the first virtualized asset used to update the single first virtualized asset, the method further including steps in which one or more processors obtain from the server computing device metadata indicating when the user computing device can delete a portion of the single first virtual asset, the one or more processors virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset, the one or more processors apply the patch to the single first virtual asset to construct the single second virtual asset, the single second virtual asset including a second plurality of assets forming the patched application, the method further including, during application of the patch, deleting the portion of the single first virtual asset based on the metadata.

[0016] In another example, various aspects of these techniques are directed to a user computing device, the user computing device comprising a memory configured to store a patch, the patch identifying how to update a first virtual asset representing an unpatched application to obtain a single second virtual asset representing the patched application, the patch including a portion of the second virtualized asset used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors being configured to apply the patch to the single first virtual asset to construct the single second virtual asset, the single second virtual asset including a second plurality of assets forming the patched application, the one or more processors further being configured to delete the portion of the single first virtual asset based on the metadata during application of the patch.

[0017] In another example, various aspects of these techniques are directed to a non-transitory computer-readable storage medium storing instructions that, when executed, cause one or more processors of a user computing device to obtain a patch from a server computing device, the patch identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, the patch including a portion of the second virtualized asset used to update the single first virtualized asset, the instructions further causing, when executed, the one or more processors of the user computing device to virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset, apply the patch to the single first virtual asset to construct the single second virtual asset, the single second virtual asset including a second plurality of assets that form the patched application, the instructions further causing, when executed, the one or more processors of the user computing device to delete, during application of the patch and based on the metadata, the portion of the single first virtual asset.

[0018] Details of one or more examples are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of the disclosure will be apparent from the description and drawings, and from the claims.

Brief Description of the Drawings

[0019]

Figure 1

Figure 2

Figure 3

Figure 4

Figure 5A

Figure 5B

Figure 6

DETAILED DESCRIPTION OF THE INVENTION

[0020] DETAILED DESCRIPTION FIG. 1 is a conceptual diagram showing an example of a computing system in which a computing device can execute various aspects of the memory-efficient patching technology described in the present disclosure. As shown in FIG. 1, the computing system 100 may include a computing device 102 and an application provider server 104. The computing device 102 may correspond to any type of device capable of executing an application such as application 130A and supports the application of software patches (sometimes referred to as "patches") to such applications. For example, the computing device 102 may be a mobile phone or handset (including so-called "smartphones"), a streaming media device (including those directly inserted into a TV port), a dedicated game system, a portable game system, a streaming game system, a TV (including so-called "smart TVs"), a wireless speaker, a smart hub, a clock (including so-called "smartwatches"), smart glasses, a smart ring or other wearable device, an extended reality device (such as a virtual reality (VR) device, an augmented reality (AR) device, etc.), a digital video disc (DVD) player, a Blu-ray (trademark) player, a laptop computer, a desktop computer, a workstation, or any other device capable of executing an application.

[0021] As shown in the example of FIG. 1, the computing device 102 includes a user interface component (UIC) 144, a UI module 146, and an application It includes an installer 148 and the application 130A before receiving a patch for the application 130A. The UIC 144 of the computing device 102 may function as an input and / or output device for the computing device 102. The UIC 144 may be implemented using various technologies. For example, the UIC 144 may function as an input device using a presence sensing input screen such as a resistive touch screen, a surface acoustic wave touch screen, a capacitive touch screen, a projected capacitance touch screen, a pressure sensitive screen, an acoustic pulse recognition touch screen, or another presence sensing display technology.

[0022] The UI module 146 may manage user interactions between the UIC 144 and other components of the computing device 102. The UIC 144 and the UI module 146 may receive one or more displays of input (such as voice input, gesture input, etc.) from the user when the user interacts with the user interface displayed by the UIC 144. The unpatched application 130A may correspond to the application currently installed on the computing device 102. The example of FIG. 1 shows a single application 130A currently installed on the computing device 102, but any number of applications may be installed on the computing device 102, and it should be understood that the computing device 102 is not necessarily limited to installing only one application on the computing device 102.

[0023] The application installer 148 may correspond to a module or unit configured to install the unpatched application 130A on the computing device 102. Also, the application installer 148 may display an interface provided by the application provider server 104, and a user of the computing device 102 may interact with this interface via the UIC 144 and / or the UI module 146 to download the unpatched application 130A. The application installer 148 may communicate with the application provider server 104 to prepare for the download of the unpatched application 130A, and when the application installer 148 receives the unpatched application 130A, it may perform various operations for installing the unpatched application 130A, such as restoring (sometimes referred to as "unzipping") the unpatched application 130A and memory management.

[0024] The UIC 144, UI module 146, application installer 148, and unpatched application 130A may perform the operations described herein using hardware or a combination of hardware and software and / or firmware that is present within and / or executed by the computing device 102. The computing device 102 may execute the UI module 146, application installer 148, and unpatched application 130A using multiple processors or multiple devices. In some cases, the computing device 102 may execute the UI module 146 and / or application installer 148 as a virtual machine executed on underlying hardware. Also, the UI module 146 and / or application installer 148 may be executed as one or more services of an operating system or computing platform, or as one or more executable programs in an application layer of the computing platform.

[0025] Application 130A may include one or more assets 132A - 132N (the "assets 132"). The assets 132 may mean resources accessed during the execution of the application, such as images, textures, files, scripts, video data, audio data, etc. It should be understood that the assets 132 of the unpatched application 130A cannot be accessed by other applications installed on the computing device 102 without the explicit permission of the unpatched application 130A. Thus, the assets 132 cannot include shared libraries or other data accessed by multiple different applications. Similarly, the unpatched application 130A cannot access the assets of different applications. In some examples, the computing device 102 may execute the unpatched application 130A in a sandbox environment that isolates the assets 132 of the unpatched application 130A from other applications.

[0026] As further shown in the example of FIG. 1, computing device 102 may communicate with application provider server 104 via network 108, which may correspond to any public or private communication network for transmitting data between computing systems, between servers, and between computing devices, such as a cellular, Wi-Fi, and / or other type of network. Network 108 may include one or more network hubs, network switches, network routers, or other network devices that operatively couple to provide for the exchange of information between application provider server 104 and computing device 102. Computing device 102 and application provider server 104 may send and receive data via network 108 using any suitable communication technology. Each of computing device 102 and application provider server 104 may be operatively coupled to network 108 using respective network links. The links that couple computing device 102 and application provider server 104 to network 108 may be Ethernet or other types of network connections, and such connections may be wireless connections and / or wired connections.

[0027] The application provider server 104 may correspond to any suitable remote computing system such as one or more desktop computers, laptop computers, mainframes, servers, cloud computing systems, etc. that can send and receive information with a network such as the network 108. The application provider server 104 hosts an application (or at least provides access to the application), displays the above interface (such as an application store (not shown in the example of FIG. 1 for ease of explanation)), and through this interface, the computing device 102 may access the application and download it to the computing device 102 via the network 108.

[0028] The application provider server 104 may perform the described operations using hardware or a mixture of hardware, software, and firmware that exists within and / or is executed by the application provider server 104. The application provider server 104 may perform various operations described herein using multiple processors or multiple devices. Also, the application provider server 104 may execute various modules or units described in more detail below as virtual machines executed on the underlying hardware. In some examples, the applic ation provider server 104 may execute an interface through which it accesses the application as one or more services of an operating system or computing platform, or as one or more executable programs in the application layer of the computing platform.

[0029] The application provider server 104 may include a patch generation unit 116, and the patch generation unit 116 may generate a patch 117 for the unpatched application 110A. The patch generation unit 116 may execute various patching algorithms to generate a patch 117 such as a difference (``Gdiff''), bsdiff, etc., generate a base binary difference between the unpatched application 110A and the patched application 110B, and in some cases compress these binary differences (along with other operations performed on the binary differences) to form the patch 117.

[0030] That is, each of the unpatched application 110A and the patched application 110B may correspond to compiled source code (or, in other words, executable binary code such as bytecode or some derivative thereof) that configures or programs a processor (or other hardware) to perform various operations. The patch generation unit 116 may be equivalent to a unit configured to determine the difference between the unpatched application 110A and the patched application 110B and output a list of commands 121 and differences 123 (``diff123'') (both the commands 121 and the differences 123 form the patch 117) for updating the unpatched application 110A to the patched application 110B. The commands 121 may identify one or more deletion operations, one or more copy operations, and / or one or more write operations (or any combination thereof), and these operations instruct the computing device 102 how to operate on the unpatched application 130A to generate the patched application 130B (the unpatched application 130A may correspond to a different instance of the unpatched application 110A, and the patched application 130B may correspond to a different instance of the patched application 110B).

[0031] When the patch 117 is generated, the application provider server 104 may connect to the app installer 148 executed by the computing device 102 and display that the patch 117 is available for download. In some cases, in response to the display that the patch 117 is available, the app installer 148 may generate a notification or other display indicating that the patch 117 is available for download and installation for the unpatched application 130A. In this case, the user of the computing device 102 may connect to the app installer 148 via the UIC 144 and / or the UI module 146 to initiate the download and installation of the patch 117. In other cases, the app installer 148 may automatically download and install the patch 117 in response to the display that the patch 117 is available. The user may specify in the system settings or per application that automatic patching is enabled, and specify the time and / or day when automatic patching can occur.

[0032] Nevertheless, the computing device 102 may obtain the patch 117 from the application provider server 104 and install the patch 117 on the unpatched application 130A to generate the patched application 130B. The purpose of such patching is to enable the developer of the application 110A / 130A to add additional features, correct software errors (so-called "software bugs"), prevent malicious attacks, update graphic or other functions without having to download a completely new application (which, due to its size, can consume a significant amount of bandwidth, i.e., both the bandwidth of the network 108 and the memory and / or storage bandwidth of the computing device 102, the processor cycles of the computing device 102, etc.).

[0033] Patching can generally improve the operation of computing device 102 by improving the operation of application 110A / 130A. However, patch 117 may still be large in certain cases (e.g., on the order of several gigabytes (e.g., several gigabytes to dozens of gigabytes), on the order of several megabytes (e.g., several hundred megabytes), etc.). For example, a developer may update the assets 112A - 112N (the "assets 112") of the unpatched application (which means an instance of asset 132) to improve graphic fidelity, update textures, add or remove video data and / or audio data, or perform other exemplary updates to improve the user experience of the unpatched application 110A. Thus, the patched application 110B may include a different set of assets 122A - 122N (the "assets 122"), and one or more of the assets 122 may be different from the assets 112 (however, in some cases, one or more of the assets 122 may be the same as the assets 112). In this example, the patch generation unit 116 does not determine whether there is a large difference, if any, between the compiled source code of the unpatched application 110A and the compiled source code of the patched application 110B, but rather only points out that there is a difference between the assets 112 and 122, resulting in a diff 123 that mainly includes assets that replace the assets of assets 112 or assets that are added to the assets of assets 112.

[0034] In some cases, for the patching process, computing device 102 may have insufficient storage space (e.g., memory and / or storage space) to store unpatched application 130A, patched application 130B, and patch 117. In other words, to apply patch 117, computing device 102 may download the entire patch 117 while storing the entire unpatched application 130A and reserve available space in memory and / or storage for the patched application 130B. Next, computing device 102 may repeatedly execute the commands 121 of patch 117 to perform one or more of the above actions to build the patched application 130B from the unpatched application 130A and diff 123. Although these techniques are described in terms of assets, these techniques may be performed on compiled source code or other types of files, resources, and / or data not described in detail in this disclosure.

[0035] To illustrate how a computing device with limited memory and / or storage is affected by this process, assume that computing device 102 has only 1.4 gigabytes (GB) of available memory and is installing a patch 117 that is 400 megabytes (MB) in size for an unpatched application 130A that is 1 GB in size, resulting in a patched application 130B that is 1.2 GB in size. In this exemplary explanation, computing device 102 has 400 of its 1.4 GB of available memory By downloading patch 117 that consumes MB, the available memory becomes only 1GB. If computing device 102 attempts to allocate 1.2GB of memory for patched application 130B, the memory manager of computing device 102 (not shown for simplicity) may reject the request due to insufficient available memory (since 1.2GB is greater than the 1GB of available memory). Thus, computing device 102 cannot apply patch 117 to unpatched application 130A.

[0036] Due to the inability to apply patch 117, computing device 102 cannot execute patched application 130B, thereby depriving the user of additional features, updated graphics, audio experience, video experience, etc., or exposing computing device 102 to security vulnerabilities. Computing devices such as computing device 102 continue to evolve, so such computing devices are increasingly used over time, and the lack of available memory often becomes an obstacle to proper patch application (such as in the case of a smartphone that stores large amounts of personal information in the form of videos, text (including text messages, emails, etc.), images (such as photos), etc.).

[0037] In accordance with various aspects of the technology described in this disclosure, the application provider server 104 may segment the patch 117 into a plurality of patch segments 127A - 127N (the "segments 127") and provide the segments 127 to the computing device 102 (which may correspond to an example of a "user computing device"), thereby enabling the computing device 102 to install the patch more efficiently (in terms of memory consumption). The computing device 102 may obtain the patch 117 from the application provider server 104 (which may also be referred to as the "server"). The application provider server 104 may segment the patch 117 into one or more segments 127 having a total number of bytes less than the entire patch 117, and each of the segments 127 may be individually installable on the unpatched application 110A / 130A. The application provider server 104 may individually transmit each segment of the one or more segments 127 to the computing device 102.

[0038] Computing device 102 may receive patch 117 in the form of individual segments 127 of one or more segments 127, and then install each individual segment one at a time (although this is done in some cases, in other cases, two or more segments 127 may be required to install some larger portion or all of asset 122A in diff 123). After installing each segment, computing device 102 may request the next segment of segments 127 and repeat this process until the entire patch 117 is systematically applied to unpatched application 130A. Also, application provider server 104 may send additional metadata 119 indicating when computing device 102 may delete various assets 132 of unpatched application 130A, whereby additional memory may be freed by deleting a portion of unpatched application 130A (or, in other words, available memory may increase), so that the memory consumed by user computing device 102 during the application of patch 117 (in the form of iterative application of segments 127) can be further reduced.

[0039] During operation, a software developer may connect to application provider server 104 to upload patched application 110B and request that application provider server 104 generate patch 117. In response to a request for application provider server 104 to generate patch 117, application provider server 104 may call patch generation unit 116, and patch generation unit 116 may execute one or more of the above patching algorithms to generate patch 117 based on the difference between unpatched application 110A and patched application 110B.

[0040] Since the patching algorithm may perform diff on a per-file basis rather than across the entire file, the patch generation unit 116 may virtualize the unpatched application 110A including all assets 112 as a single virtual asset 114. The patch generation unit 116 may execute a virtualization algorithm that provides a multi-layer memory and / or storage file hierarchy having folders and sub-folders in which the unpatched application 110A including the assets 112 is stored as a single virtual asset 114A. Also, the patch generation unit 116 may virtualize the patched application 110B including the assets 122 so as to provide a multi-layer memory and / or storage file hierarchy having folders and sub-folders in which the unpatched application 110B including the assets 122 is stored as a single virtual asset 114B. Next, the patch generation unit 116 may execute the patching algorithm on the single virtual asset 114B to generate the commands 121 and diff 123 of the patch 117, and the command 121 identifies the operations to be performed on the unpatched application 110A for generating the patched application 110B based in part on the diff 123.

[0041] Although described as performing virtualization, if the server 104 can receive the assets as archives (or in other words, virtualized assets), the patch generation unit 116 may not need to perform virtualization. Instead, the server 104 may virtualize the assets 122 upon upload by the developer and then store the virtualized assets as the virtual asset 114B.

[0042] The patch generation unit 116 may output a patch 117. As a result, the application provider server 104 may be connected in the above-described manner to notify the computing device 102 about the patch 117. Next, the computing device 102 may request the patch 117 from the application provider server 104 via the above interface, and call the app installer 148 to download and install the patch 117. In response to the request for the patch 117, the application provider server 104 may call the patch segmentation unit 118. The patch segmentation unit 118 may correspond to a module or unit configured to segment the patch 117 into one or more patch segments 127. The patch segmentation unit 118 may create each of the segments 127 such that a subset of the commands 121 and the corresponding portions of the diff 123 are completely contained within each of the segments 127.

[0043] In some cases, the patch segmentation unit 118 may not be able to store all of a given portion of the diff 123 that is referenced by a certain command among the commands 121 included in one of the segments 127. As a result, that portion of the diff 123 is somewhat fragmented across two or more of the segments 127. In these cases, the patch segmentation unit 118 may disperse that portion of the diff 123 across two or more of the segments 127, such that the computing device 102 caches a particular one of the segments 127 until the entire portion of the diff 123 is available for storage in the patched application 130B. However, in other examples, the patch segmentation unit 118 may generate the segments 127 such that each of the segments 127 is individually installable by the computing device 102.

[0044] To facilitate the explanation, assuming that each of the segments 127 is individually installable by the computing device 102, the application provider server 104 may output each of the segments 127 to the computing device 102 individually (e.g., one at a time). The computing device 102 may receive a segment such as segment 127A shown in the example of FIG. 1, including a subset of the commands 121 (e.g., commands 121A to 121N (which may also be referred to as "command subset 121")) and a subset of the diff segments 123 referred to by the command subset 121 (e.g., "diff seg123A to 123N" (which may also be referred to as "diff seg123")).

[0045] In response to receiving segment 127A, the computing device 102 may invoke the segmented patch application unit 136, which corresponds to a unit configured to repeatedly apply the patch 117 as a sequence of segments 127. To apply segment 127A, the segmented patch application unit 136 may first virtualize the unpatched application 130A in a manner similar to but not necessarily identical to the manner described above with respect to the patch generation unit 116 to create a virtual asset 134A.

[0046] Next, the segmentation patch application unit 136 may execute command 121 to delete asset 142 from virtual asset 134B representing the patched application 130B, copy it from virtual asset 134A to virtual asset 134B, and write one or more portions (in the form of diff segment 123) of the virtual asset representing the patched application 130B to virtual asset 134B. That is, command 121 may indicate how to update a single virtual asset 134A to obtain a single virtual asset 134B. Thus, the segmentation patch application unit 136 may apply a single segment 127A to virtual asset 134A to populate, or in other words, construct virtual asset 134B.

[0047] In addition or as an alternative, the patch generation unit 116 may generate metadata 119 indicating when computing device 102 can delete a portion of virtual asset 134A while obtaining patch 117. The patch generation unit 116 may generate metadata 119 as a series of one or more instructions 129A - 129N, and each of the series of one or more instructions 129A - 129N includes a read index and a subsequent indication identifying the associated asset of asset 132 or other portions of unpatched application 130A. In FIG. 1, instruction 129 includes two examples where, after read indices of -1 and 213, an asset name, reference, or other identifier (denoted as "ASSET" in the example of FIG. 1) follows.

[0048] Patch generation unit 116 may include a read counter 139 ( "RC139") that is incremented by patch generation unit 116 after each reading of unpatched application 110A. When one of assets 112 is read, patch generation unit 116 may update metadata 119 to indicate that one of the read indexes of assets 112 is equal to read counter 139, and identify a display that identifies one of assets 112 after the read index. Patch generation unit 116 may thus systematically generate metadata 119 for assets 112 or other portions of unpatched applications 110A / 130A represented by virtual assets 114A / 134A to indicate when they may be deleted (or, in other words, marked as available memory and / or storage). Patch generation unit 116 may identify this read index and the corresponding asset identifier as instruction 129 within metadata 119.

[0049] Patch generation unit 116 may provide metadata 119 to patch segmentation unit 118, and patch segmentation unit 118 may add metadata 119 to a first segment (assumed to be segment 127A for purposes of illustration) sent to computing device 102. Application provider server 104 may send metadata 119 to computing device 102 having segment 127A.

[0050] As described above, the computing device 102 may call the segmentation patch application unit 136 to process the segment 127A. As a result, the segmentation patch application unit 136 may parse the metadata 119 from the segment 127A. Next, the segmentation patch application unit 136 may maintain the read counter 139 in the same manner as described above with respect to the patch generation unit 116. Each time the read index in the metadata 119 matches the read counter 139, the segmentation patch application unit 136 may delete one of the assets 132 identified by the corresponding asset identifier (more generally, any portion of the unpatched application 130A).

[0051] In some examples, the read index may have a negative value (such as -1), which means that the corresponding asset of the assets 132 can be deleted without referring to the read counter 139 (for example, because it has been reversed, swapped, or completely removed). In these examples, the segmentation patch application unit 136 may first process the metadata 119 to delete all the assets 132 identified by the application identifier with the corresponding read index having a negative value, looking ahead.

[0052] In this way, the segmented patch application unit 136 may continue to repeatedly receive segment 127 and individually apply each of segment 127 before applying consecutive segments of segment 127. In some examples, the segmented patch application unit 136 connects to the application provider server 104 to provide confirmation that the previous segment of segment 127 was successfully applied, and only upon receiving this confirmation, the application provider server 104 may send the next segment of segment 127, ensuring that available memory resources are conserved so that the application of patch 117 is successfully completed.

[0053] Similarly, the segmented patch application unit 136 may continue to maintain a read counter 139 as segment 127 is repeatedly applied to the virtual asset 134A. The segmented patch application unit 136 may continue to refer to the read counter 139 for the instruction 129 of the metadata 119 and may delete the corresponding asset of the asset 132 each time the read counter 139 matches a read index of one of the instructions 129.

[0054] Accordingly, the described technique can improve the operation of the computing device 102 and the computing system including the computing device 102 and the application provider server 104. By receiving patch 117 and installing it into segment 127, the described technique is a patch 117The amount of storage required by computing device 102 to install can be reduced, and the performance of computing device 102 can be improved (patching can improve the processing throughput during patch application and reduce bandwidth utilization, including memory bandwidth utilization, by being extracted over time). Also, by enabling deletion of a portion of the unpatched application 130A during application of segment 127 of patch 117 to the unpatched application 130A, memory utilization can be further reduced, thereby improving the performance of computing device 102.

[0055] FIG. 2 is a block diagram showing an example of an application provider server configured to perform various aspects of the efficient patching techniques described in the present disclosure. FIG. 2 shows only one specific example of application provider server 204, and in other examples, many other examples of application provider server 204 may be used. In other examples, the application provider server may include a subset of the components included in an example of application provider server 104, or may include additional components not shown in FIG. 2. For example, application provider server 204 may comprise a cluster of servers, and each of the servers comprising the cluster of servers that make up application provider server 204 may include all or some of the components described herein in FIG. 2 for performing the techniques disclosed herein. Thus, application provider server 204 corresponds to an example of application provider server 104.

[0056] As shown in the example of FIG. 2, the application provider server 204 includes one or more processors 240, one or more communication units 242, and one or more storage devices 248. The processor 240 may execute functions and / or execute instructions associated with the application provider server 204. Examples of the processor 240 include an application processor, a display controller, an auxiliary processor, one or more sensor hubs, and other hardware configured to function as a processor, processing unit, or processing device. The patch generation unit 116, the patch segmentation unit 118, and the application store interface 260 may be executed by the processor 236 to perform various actions, operations, or functions of the application provider server 204. For example, the processor 240 may retrieve and execute instructions stored by the storage device 248 (and represented by the patch generation unit 116, the patch segmentation unit 118, and the application store interface 260), and these instructions cause the processor 240 to perform the operations described herein with respect to the patch generation unit 116, the patch segmentation unit 118, and the application store interface 260. When executed by the processor 240, these instructions may cause the application provider server 204 to store information in the storage device 248.

[0057] The communication unit 242 may correspond to a unit configured to communicate with an external device (e.g., the computing device 102) via one or more wired and / or wireless networks (e.g., the network 108) by transmitting and receiving network signals via one or more networks. Examples of the communication unit 242 include a network interface card (e.g., an Ethernet card, etc.), an optical transceiver, a radio frequency transceiver, a Global Positioning Satellite (GPS) receiver, a cellular - A transceiver, or other types of devices capable of transmitting and receiving data, can be mentioned. Other examples of the communication unit 242 can include a shortwave radio, a cellular data radio, a wireless network radio, and a Universal Serial Bus (USB) controller.

[0058] The storage device 248 can correspond to one or more memories and / or storage devices configured to store information for processing during the operation of the application provider server 204. In some examples, the storage device 248 can correspond to a temporary memory, which means that the main purpose of the storage device 248 is not long-term storage. The storage device 248 can be configured to store information as volatile memory for a short period of time and thus not retain the stored content when powered off. Examples of volatile memory can include random access memory (RAM), dynamic random access memory (DRAM), static random access memory (SRAM), and other forms of volatile memory known in the art.

[0059] In some examples, storage device 248 may also include one or more computer-readable storage media. Storage device 248 may include one or more non-transitory computer-readable storage media. Storage device 248 may be configured to store an amount of information greater than that typically stored by volatile memory. Storage device 248 may further be configured to store information as non-volatile memory space for a long period of time and retain the information after power-on / off cycles. Examples of non-volatile memory include magnetic hard disks, optical disks, floppy (registered trademark) disks, flash memory, or forms of electrically programmable memory (EPROM) or electrically erasable and programmable memory (EEPROM). Storage device 248 may store program instructions and / or information (e.g., data) associated with patch generation unit 116, patch segmentation unit 118, and / or application store interface 260. Storage device 248 may include memory configured to store data or other information associated with patch generation unit 116, patch segmentation unit 118, and / or application store interface 260.

[0060] Application provider server 204 may first receive patched application 110B via application store interface 260 (which may correspond to an interface provided to software developers, users, and other entities to interact with an electronic marketplace that serves as a basis for downloading or obtaining applications such as application 110A), from a software developer responsible for supporting application 110A. In response to receiving patched application 110B, application provider server 204 may call patch generation unit 116 to generate patch 117 representing the difference between unpatched application 110A and patched application 110B.

[0061] To generate patch 117, patch generation unit 116 may first call virtualization unit 262. Virtualization unit 262 may correspond to a unit configured to virtualize a plurality of assets, such as each of assets 112 and 122 that form applications such as each of non-patched application 110A and patched application 110B. As an example, virtualization unit 262 may extend a Java (registered trademark) class called "RandomAccessFile" such that a single RandomAccessFile object includes a plurality of files or other assets. The assets may be virtualized to appear as a single virtual asset by extending the class. In other words, virtualization unit 262 may add a plurality of different assets to each other and enclose the added assets in a RandomAccessFile object (which has an extension function for handling how the added assets are accessed and stored in the underlying file system). In this way, virtualization unit 262 may virtualize non-patched application 110A to obtain virtual asset 114A, and may virtualize patched application 110B to obtain virtual asset 114B.

[0062] Next, patch generation unit 116 may apply one or more of the above patching algorithms to virtual asset 114A and virtual asset 114B to obtain command 121 and diff 123. During the application of the patching algorithm, patch generation unit 116 may call metadata generation unit 264. Metadata generation unit 264 may correspond to a unit configured to generate metadata 119 indicating when asset 112 of non-patched application 110A may be deleted during the application of patch 117 to other instances of non-patched applications (such as non-patched application 130A of computing device 102 shown in the example of FIG. 1).

[0063] The metadata generation unit 264 may increment the read counter 139 to reflect each memory / storage device read operation performed on the asset 112. Each time the last read of an asset is performed, the metadata generation unit 264 identifies the current value of the read counter 139 as a read index together with the asset identifier, whereby it may be indicated that the identified asset can be deleted if the corresponding read counter 139 maintained in the computing device 102 is equal to the read index. Also, the metadata generation unit 264 may indicate in the metadata 119 that the asset can be deleted immediately (since the asset is not read throughout the generation of the patch 117) by identifying a negative value (such as -1) for the read index together with the application identifier in the metadata 119.

[0064] After generating the patch 117, the application provider server 204 may call the application store interface 260 to connect to the computing device 102 via the communication unit 242 and indicate that the patch 117 is available for download. Thereafter, the application provider server 204 may receive a request for the patch 117 and possibly receive the device information 267 via this request or another communication. The device information 267 may include one or more types of information about the computing device 102, but may also identify the amount of memory that can be used (sometimes referred to as "usable memory"). Next, the application provider server 204 may call the patch segmentation unit 118 and pass the device information 267 to the patch segmentation unit 118.

[0065] The patch segmentation unit 118 may segment the patch 117 into segments 127, perhaps based on the device information 267. That is, if the device information 267 indicates that the available memory is below a threshold, a size smaller than the size that would be selected (or predefined) when the device information 267 indicates that the available memory is above the threshold may be selected for each of the segments 127. However, in some cases, the patch segmentation unit 118 may segment the patch 117 into segments 127 regardless of the device information 267, and the size of each of the segments 127 may be the same, and predefined for each segment. They do not necessarily have to be the same, or may be adapted based on various criteria (such as being individually installable).

[0066] Upon generating the segments 127, the patch segmentation unit 118 may call the compression unit 266 to compress each of the segments 127 independently of each other (such that each of the segments 127 is individually decompressible). The compression unit 266 may correspond to a unit configured to apply one or more compression algorithms to the diff segments 127 and perhaps the commands 121. When compressing the segments 127, the compression unit 266 may call different compression algorithms depending on the type of content represented by the different parts of the segments 127. That is, the segments 127 may also include the entire asset 122 that may correspond to an image, video, texture, text, audio, etc., and the compression unit 266 may apply an image compression algorithm for images, a video compression algorithm for videos, a texture compression algorithm for textures, an audio compression algorithm for audio, etc. In this regard, the segments 127 may correspond to the compressed parts or segments of the patch 117.

[0067] Next, the application provider server 204 may repeatedly (possibly one at a time) output segment 127 to the computing device 102 (one segment may include metadata 119, and the patch generation unit 116 passes the metadata 119 along with the patch 117 to the patch segmentation unit 118). The application provider server 204 may output only consecutive segments in response to confirmation from the computing device 102 indicating that the current segment has been successfully applied to the virtual asset 134A representing the unpatched application 130A. The application provider server 204 may thus repeatedly execute to supply a single segment of segment 127 at a time until each of segment 127 has been successfully applied to the virtual asset 134A to generate the virtual asset 134B.

[0068] FIG. 3 is a block diagram illustrating an example of a computing device configured to download and install one or more patches according to one or more aspects of the present disclosure. FIG. 3 shows only one specific example of the computing device 302, and in other examples, many other examples of the computing device 302 may be used, and many other examples of the computing device 302 may include a subset of the components included in an example of the computing device 302, or may include additional components not shown in FIG. 3. The computing device 302 may correspond to an example of the computing device 102 shown in the example of FIG. 1.

[0069] As shown in the example of FIG. 3, computing device 302 includes a user interface component (UIC) 344, one or more processors 336, one or more communication units 338, and one or more storage devices 328, each of which is interconnected by a communication channel 330 (which may be similar but not necessarily identical to communication channel 250 shown in the example of FIG. 2). UIC 314 may be similar but not necessarily identical to UIC 144 shown in the example of FIG. 1. Processor 336 may be similar but not necessarily identical to processor 240 shown in the example of FIG. 2. Communication unit 338 may be similar but not necessarily identical to communication unit 242 shown in the example of FIG. 2. Storage device 328 may be similar but not necessarily identical to storage device 248 shown in the example of FIG. 2.

[0070] As further shown in the example of FIG. 3, the user interface component 344 may include one or more input components 332 and one or more output components 334. One or more input components 332 of the computing device 302 may receive an input. Examples of inputs are tangible inputs, voice inputs, and video inputs. In one example, the input component 332 includes a presence sensing input device (e.g., a touch-sensitive screen, a presence sensing display), a mouse, a keyboard, a voice response system, a video camera, a microphone, or other types of devices for detecting inputs from humans or machines. In some examples, the input component 332 may include one or more sensor components such as one or more position sensors (GPS component, Wi-Fi component, cellular component), one or more temperature sensors, one or more motion sensors (e.g., accelerometer, gyro), one or more pressure sensors (e.g., barometer), one or more ambient light sensors, and one or more other sensors (e.g., microphone, camera, infrared proximity sensor, hygrometer, etc.). Other sensors may include, by way of several other non-limiting examples, a heart rate sensor, a magnetometer, a glucose sensor, a hygrometer sensor, an olfactory sensor, a compass sensor, a step counter sensor.

[0071] One or more output components 334 of the computing device 302 may generate an output. Examples of outputs are tangible outputs, voice outputs, and video outputs. In one example, the output component 334 of the computing device 302 includes a PSD, a sound card, a video graphics adapter card, a speaker, a cathode ray tube (CRT) monitor, a liquid crystal display (LCD), or other types of devices for generating outputs to humans or machines.

[0072] Although the UIC 344 is shown as an internal component of the computing device 302, it may also correspond to an external component that shares data paths for sending and receiving inputs and outputs with the computing device 302. For example, in one instance, the UIC 344 is located within the external packaging of the computing device 302 and corresponds to a built-in component of the computing device 302 (e.g., the screen of a mobile phone) physically connected to the external packaging of the computing device 302. In another example, the UIC 344 is located outside the packaging or housing of the computing device 302 and corresponds to an external component of the computing device 302 (e.g., a monitor, projector, etc.) physically separated from the packaging or housing of the computing device 302 that shares wired and / or wireless data paths with the computing device 302.

[0073] One or more storage devices 328 within the computing device 302 may store information for processing during the operation of the computing device 302 (e.g., the computing device 302 may store data accessed by the UI module 146, application installer 148, unpatched applications 130A, and one or more segments 127 during execution by the computing device 302). The storage device 328 may store program instructions and / or information (e.g., data) associated with the segmentation patch application unit 136, UI module 146, application installer 148, application 130A, and segment 127A. The storage component 328 may include a memory configured to store data or other information associated with the segmentation patch application unit 136, UI module 146, application installer 148, application 130A, and segment 127A.

[0074] As described above, the application installer 148 may be executed by the processor 236 to install a patch on the computing device 302. The application installer 148 may perform the functions of an application marketplace application that enables a user to interact with the application store interface 260 via the UIC 344 to browse, download, and install a patch from an application provider server, such as the application provider server 204 shown in the example of FIG. 2. The UIC 344 may receive a display indicating a request to download a patch, such as patch 117, for the unpatched application 130A, and the UI module 146 may transfer this request to the application installer 148. In response to the display of the request to download patch 117, the application installer 148 may then send this request to the application provider server 204.

[0075] In response to sending a request for patch 117 to application provider server 204, application installer 148 may receive patch 117 from application provider server 204 in the form of each individual segment of segment 127. Application installer 148 may receive segment 127A of patch 117 in a compressed form for application 130A, the purpose being to reduce the time required to download segment 127A and to reduce the network resources used for the download. Each asset 142 (or a portion thereof) within diff segment 123 of segment 127A may be compressed (e.g., by application provider server 204) using a compression algorithm specific to the type of asset 142 to reduce the size of segment 127A that is transmitted over the network to computing device 302. Thus, if application segment 127A includes two or more assets 142 of two or more different types, each of the two or more types of assets 142 may be compressed using different compression algorithms as described in detail above.

[0076] To restore asset 142 represented as diff segment 123 of segment 127A, segmentized patch application unit 136 may call restore unit 366, which may store a compression dictionary for assets compressed using a dictionary-based compression algorithm, in which data blocks such as character strings can be replaced by referring to the positions of data blocks in the compression dictionary. The compression dictionary may include indexes of data blocks that can be indexed by a dictionary-based compression algorithm for compressing and restoring data. To restore an application element compressed using a dictionary-based compression algorithm, restore unit 366 may replace references in the compressed asset with data blocks at corresponding reference positions in the compression dictionary.

[0077] When computing device 302 downloads segment 127A, the segmented patch application unit 136 may call the virtualization unit 362. The virtualization unit 362 may correspond to a unit configured to virtualize an unpatched application 130A that is patched in a manner similar to, but not necessarily the same as, the manner described above with respect to the virtualization unit 262 of the application provider server 204 shown in the example of FIG. 2. The virtualization unit 362 may create a single virtual asset 134A such that the unpatched application 130A including the asset 132 appears as a single file.

[0078] Next, the segmented patch application unit 136 may extract the command 121 and start applying the diff segment 123 according to the command 121. In the copy command of the command 121, the segmented patch application unit 136 may move one or more assets 132 (or a part thereof) from the virtual asset 134A to the virtual asset 134B, and such copied assets are shown here as the asset 142. In the delete command of the command 121, the segmented patch application unit 136 may delete the identified asset among the assets 132. In the write command of the command 121, the segmented patch application unit 136 may write one or more of the diff segments 123 to the virtual asset 134B, and the virtual asset 134B is also shown as the asset 142.

[0079] ​As described above, the patch generation unit 116 may call the compression unit 266 to compress the diff segment 123. Therefore, in order to write the diff segment 123, the segmented patch application unit 136 may call the restoration unit 366, and the restoration unit 366 may restore the asset 142 referred to by the command 121 included in the segment 127A by restoring the segment 127A. However, instead of storing both the compressed asset and a temporary copy of the asset during extraction (or restoration, in other words), the restoration unit 366 may further save memory consumption by directly extracting the asset at its final position in the file system. To facilitate direct writing to the underlying file system, the patch generation unit 116 of the application provider server 204 may write additional headers (referred to as local file headers (LFHs)) before each of the new assets (for example, one or more of the assets 142) is stored in a patch 117 indicating the storage location of each of the new assets.

[0080] The restoration unit 366 may refer to each of the local file headers and save the local file headers in memory. Referring to the local file headers, the restoration unit 366 may directly extract the diff segment 123 with respect to the file system at the positions specified in the local file headers. Therefore, the restoration unit 366 can avoid maintaining a temporary copy of the diff segment 123 in memory before moving a copy of the diff segment 123 to the corresponding position in the file system.

[0081] In any case, the segmentation patch application unit 136 may call the restoration unit 366 for each diff segment 123 when each is referenced by the command 121. This is because the extraction directly writes each of the diff segments 123 in the restored form to the virtual asset 134B (as one of the assets 142). Thus, the segmentation patch application unit 136 can probably process the segment 127A in a more memory - efficient manner. The segmentation patch application unit 136 may repeat this process for each of the segments 127 until the patch 127 is completely installed.

[0082] In some examples, the segmentation patch application unit 136 may detect a system failure during the installation of a segment (e.g., segment 127A), and may resume the installation of the segment by periodically generating checkpoint elements. In the example of FIG. 3, the checkpoint element 367 for the segment 127A may be periodically generated and stored within the storage component 328 The checkpoint element 367 may include one or more of an asset name, an asset status, an asset offset, the remaining bytes of the asset that were applied during the installation of the segment 127A, and the indication of the next segment to be applied. The asset name indicates the asset that was being applied at the time of the system failure.

[0083] The asset status indicates that a system failure occurred during the asset installation process or during the local file header reading process for the asset. In one of these examples, a value of zero may indicate that a system failure occurred during the asset installation process, and a value of one may indicate that a system failure occurred during the local file header reading process.

[0084] The asset offset indicates the position at which to start applying the next segment. The remaining bytes indicate the position at which to resume installing the asset. The next segment element indicates the next segment to install. Thus, using the checkpoint element 367, the segmented patch application unit 136 may resume installing segments when a system failure occurs.

[0085] Also, the segmented patch application unit 136 may also receive metadata 119 that identifies when the segmented patch application unit 136 may delete the asset 132. That is, the segmented patch application unit 136 may receive the metadata 119 along with the first segment (e.g., segment 127A) transmitted to the computing device 302, and in some examples, the metadata 119 may be appended to the segment 127A. In response to receiving the segment 127A, the segmented patch application unit 136 may call the metadata processing unit 364. The metadata processing unit 364 corresponds to a unit configured to parse the metadata 119 from the segment 127A, and may then process the metadata 119 to remove the asset 132 during the application of the segment 127 (or, in other words, during the application of the patch 117).

[0086] Next, the metadata processing unit 364 may maintain the read counter 139 in the same manner as described above with respect to the patch generation unit 116. Each time the read index in the metadata 119 matches the read counter 139, the segmented patch application unit 136 may delete one of the assets 132 identified by the corresponding asset identifier (more generally, any portion of the unpatched application 130A).

[0087] In some examples, the read index may have a negative value (such as -1), which means that the corresponding asset in the asset 132 can be deleted without referring to the read counter 139 (for example, because it has been reversed, exchanged, or completely removed). In these examples, the metadata processing unit 364 may first process the metadata 119 to delete all the assets 132 (for example, asset 132A) identified by the application identifier with the corresponding read index having a negative value, looking ahead.

[0088] In this way, the segmentation patch application unit 136 may continue to receive the segment 127 repeatedly and apply each of the segments 127 individually before applying consecutive segments among the segments 127. In some examples, the segmentation patch application unit 136 may connect to the application provider server 204 to provide confirmation that the previous segment among the segments 127 has been successfully applied, and only after receiving this confirmation, the application provider server 104 may send the next segment among the segments 127, ensuring that the available memory resources are saved so that the application of the patch 117 is successfully completed.

[0089] Similarly, the metadata processing unit 364 may continue to maintain the read counter 139 as the segment 127 is repeatedly applied to the virtual asset 134A The metadata processing unit 364 may continue to refer to the read counter 139 for the instruction 129 of the metadata 119, and may delete the corresponding asset among the assets 132 each time the read counter 139 matches one of the read indexes of the instruction 129.

[0090] Figure 4 is a block diagram showing an example of a virtual asset generated by the system of FIG. 1 according to various aspects of the technology described in the present disclosure. In the example of FIG. 4, the virtual asset 418 may correspond to any one of the virtual assets 114A, 114B, 134A, and / or 134B. The virtual asset 418 may include assets 416A to 416N (the "assets 416"), local file headers (LFHs) 440A to 440N (the "LFHs 440") that may indicate corresponding positions in memory for storing the associated assets among the assets 416, and a central directory 422 that defines a file system based on the central directory in which the assets 416 are stored.

[0091] To generate the virtual asset 418, the system 100 (either or both of the application provider server 104 and the computing device 102) may call a modified RandomAccessFile function that can process multiple files across the file system hierarchy, move between folders and subfolders, and identify each of the assets 416 stored in the central directory 422. Thus, the system 100 may create an LFH 440 for each of the assets 416 and generate an LFH among the LFHs 440 that identify the position of the asset 416 with respect to the central directory 422 for each of the assets 416, thereby enabling each of the assets 416 to be directly extracted at the storage location of each of the assets 416 during restoration (thereby avoiding the temporary copy described above with respect to the example of FIG. 3).

[0092] Figures 5A and 5B are flowcharts showing an example of the operation of the application provider server shown in the example of FIG. 2 when providing a patch to the computing device shown in the example of FIG. 3 in accordance with the memory - efficient patching technique described in the present disclosure. The application provider server 204 first receives (498) the unpatched application 110A via the application store interface 260, and then may receive (500) the patched application 110B from a software developer responsible for supporting the application 110A. In response to receiving the patched application 110B, the application provider server 204 may call the patch generation unit 116 to generate a patch 117 representing the difference between the unpatched application 110A and the patched application 110B. In this regard, the patch generation unit 116 may generate the patch 117 based on the unpatched application 110A and the patched application 110B.

[0093] To generate the patch 117, the patch generation unit 116 may first call the virtualization unit 262. The virtualization unit 262 may virtualize a plurality of assets such as the assets 112 and 122 that form applications such as the respective unpatched application 110A and the patched application 110B. The virtualization unit 262 may add a plurality of different assets to each other and encapsulate the added assets as a single object (having an extension for handling how the added assets are accessed and stored in the underlying file system). Thus, the virtualization unit 262 may virtualize the unpatched application 110A to obtain a first virtual asset 114A (502), and may virtualize the patched application 110B to obtain a second virtual asset 114B (5 04).

[0094] Next, the patch generation unit 116 may apply one or more of the above patching algorithms to the virtual asset 114A and the virtual asset 114B to obtain the command 121 and the diff 123, and the command 121 and the diff 123 may collectively correspond to the patch 117 (506). After generating the patch 117, the application provider server 204 may call the application store interface 260, connect to the computing device 102 via the communication unit 242, and display that the patch 117 is available for download (508). The UIC 344 of the computing device 302 may receive a display indicating a request to download a patch such as the patch 117 for the unpatched application 130A (510), and the UI module 146 may transfer this request to the application installer 148. In response to the display of the request to download the patch 117, the application installer 148 may send a request for the patch 117 to the application provider server 204 (512).

[0095] Thereafter, the application provider server 204 may receive a request for the patch 117 (514), and may also receive the device information 267, perhaps via this request or another communication. The device information 267 may include information of one or more types about the computing device 102, but may also specify the amount of memory that can be used (sometimes referred to as "available memory"). Next, the application provider server 204 may call the patch segmentation unit 118 and pass the device information 267 to the patch segmentation unit 118.

[0096] The patch segmentation unit 118 may segment the patch 117 into segments 127, perhaps based on the device information 267 (516). That is, if the device information 267 indicates that the available memory is below a threshold, the patch segmentation unit 118 may select a size for each of the segments 127 that is smaller than the size that would be selected if the device information 267 indicated that the available memory is above the threshold (or that is predefined). However, in some cases, the patch segmentation unit 118 may segment the patch 117 into segments 127 regardless of the device information 267, and the size of each of the segments 127 may be the same, may be predefined for each segment but not necessarily the same, or may be adapted based on various criteria (such as being individually installable).

[0097] Upon generating the segments 127, the patch segmentation unit 118 may call the compression unit 266 to compress each of the segments 127 independently of each other (such that each of the segments 127 can be individually restored) (518). Next, the application provider server 204 may repeatedly (perhaps one at a time) output the segments 127 to the computing device 102 (one segment may include the metadata 119), and the patch generation unit 116 may pass the segments 127 to the patch segmentation unit 118 along with the patch 117. The application provider server 204 may output the first segment of the segments 127 (520).

[0098] The application installer 148 may receive the first segment 127A of the patch 117 in a compressed form for the application 130A, the purpose of which may be to reduce the time required to download the segment 127A and thus reduce the network resources used for the download. Accordingly, the application installer 148 may receive the compressed first segment 127A (522). To restore the asset 142 represented as the diff segment 123 of segment 127A, the segmentation patch application unit 136 may call the restoration unit 366, and the restoration unit 366 may restore the segment 127A (524).

[0099] Next, the virtualization unit 362 may virtualize the non-patched application 130A in a manner similar to but not necessarily the same as the manner described above for the virtualization unit 262 of the application provider server 204 shown in the example of FIG. 2 (526). The virtualization unit 362 may create a single virtual asset 134A such that the non-patched application 130A including the asset 132 appears as a single file.

[0100] Next, the segmentation patch application unit 136 may extract the command 121 and start applying the diff segment 123 according to the command 121. The segmentation patch application unit 136 may call the restoration unit 366 for each diff segment 123 when each is referenced by the command 121. This is because the extraction directly writes each of the restored diff segments 123 into the virtual asset 134B (as one of the assets 142). In this way, the segmentation patch application unit 136 can process the segment 127A in a perhaps more memory-efficient manner. In this way, the segmentation patch application unit 136 may restore the first segment 127A (527) and apply the first segment 127 to the first virtual asset to obtain a second virtual asset (528).

[0101] When the application of the initial segment 127A is successful, the segmentation patch application unit 136 may generate a confirmation that the application of the initial segment 127A is complete and send this confirmation to the application provider server 204 (530, 532). The application provider server 204 may receive this confirmation (534) and determine whether there are any further segments 127 to be sent (536). If there are further segments 127 to be sent, the application provider server 204 outputs the next segment among the segments 127 (538), and the computing device 302 may receive, restore, and apply this next segment as described above (540 - 544). The computing device 302 may generate another confirmation that the application of the received segment is complete and output this confirmation as described above (546, 532).

[0102] This process may continue until the application provider server 204 determines that there are no further segments (532 - 546). If there are no further segments to be sent to the computing device 302 ( "NO" at 536), the application provider server 204 may send a display indicating that there are no further segments (or, in other words, the entire patch has been provided and applied) (548).

[0103] FIG. 6 is another flowchart showing an example of the operation of the application provider server shown in the example of FIG. 2 when providing a patch to the computing device shown in the example of FIG. 3 in accordance with the memory - efficient patching technique described in the present disclosure. As described above, the application provider server 204 may first receive, via the application store interface 260, the patched application 110B from the software developer responsible for supporting the application 110A (600). In response to receiving the patched application 110B, the appli The cation provider server 204 may call the patch generation unit 116 to generate a patch 117 that represents the difference between the unpatched application 110A and the patched application 110B. In this regard, the patch generation unit 116 may generate the patch 117 based on the unpatched application 110A and the patched application 110B.

[0104] To generate the patch 117, the patch generation unit 116 may first call the virtualization unit 262. The virtualization unit 262 may virtualize a plurality of assets such as each of the assets 112 and 122 that form applications such as the respective unpatched application 110A and the patched application 110B. The virtualization unit 262 may add a plurality of different assets to each other and encapsulate the added assets as a single object (having an extension for handling how the added assets are accessed and stored in the underlying file system). In this way, the virtualization unit 262 may virtualize the unpatched application 110A to obtain a first virtual asset 114A (602), and may virtualize the patched application 110B to obtain a second virtual asset 114B (604).

[0105] Next, the patch generation unit 116 may apply one or more of the above-described patching algorithms to the virtual asset 114A and the virtual asset 114B to obtain the command 121 and the diff 123, and the command 121 and the diff 123 may collectively correspond to the patch 117 (606). During the application of the patching algorithm, the patch generation unit 116 may call the metadata generation unit 264, and the metadata generation unit 264 may be a unit configured to generate metadata 119 indicating when the asset 112 of the unpatched application 110A can be deleted during the application of the patch 117 to other instances of the unpatched application (such as the unpatched application 130A of the computing device 102 shown in the example of FIG. 1) (608).

[0106] After generating the patch 117, the application provider server 204 may call the application store interface 260, connect to the computing device 102 via the communication unit 242, and display that the patch 117 is available for download (610). The UIC 344 of the computing device 302 may receive a display indicating a request to download a patch such as the patch 117 for the unpatched application 130A (612), and the UI module 146 may transfer this request to the application installer 148. In response to the display of the request to download the patch 117, the application installer 148 may then send a request for the patch 117 to the application provider server 204 (614).

[0107] The application provider server 204 may then receive (616) the request for the patch 117 and output (618) the patch 117 along with the metadata 119 (perhaps as one or more segments 127 as described above). The segmentation patch application unit 136 may receive (620) the patch 117 and the metadata 119, which may identify when the segmentation patch application unit 136 may delete the asset 132. In some examples, the segmentation patch application unit 136 may receive the metadata 119 along with a first segment (e.g., segment 127A) sent to the computing device 302, and in some examples, the metadata 119 may be appended to segment 127A. In response to receiving segment 127A, the segment The patch application unit 136 may invoke the metadata processing unit 364. The metadata processing unit 364 may parse the metadata 119 from the segment 127A and then process (622) the metadata 119 to remove the assets 132 during application of the segment 127A (or, in other words, during application of the patch 117).

[0108] In this manner, the segmented patch application unit 136 may continue to repeatedly receive the segments 127 and apply each of the segments 127 individually before applying successive segments of the segments 127. In some examples, the segmented patch application unit 136 may connect to the application provider server 204 to provide confirmation that the previous segment of the segments 127 was successfully applied, and only upon receiving this confirmation may the application provider server 104 send the next segment of the segments 127, which would ensure that the application of the patch 117 is completed successfully, conserving available memory resources.

[0109] Various aspects of these techniques may enable the various examples described below with respect to the following sections.

[0110] Item 1A A method comprising: one or more processors virtualizing a first plurality of assets that form an unpatched application to obtain a single first virtual asset; the one or more processors obtaining a single second virtual asset representing a second plurality of assets that form a patched application; the one or more processors obtaining a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset used to update the single first virtual asset, the method further comprising: the one or more processors segmenting the patch into a plurality of segments; the one or more processors outputting a single segment from the plurality of segments to the user computing device for individual installation on the unpatched application by the user computing device.

[0111] Item 2A The method according to Item 1A, wherein the single segment includes a copy command and a write command indicating how to update the first virtual asset to obtain the single second virtual asset.

[0112] Item 3A generating metadata indicating when to delete a portion of the single first virtual asset; The method according to any combination of claims 1A and 2A, further comprising the step of outputting the metadata to the user computing device.

[0113] Claim 4A The metadata includes a read index, and the read index is the The method according to claim 3A, wherein after the read index, the cumulative memory reads what is to be read during the application of the plurality of segments to delete a part of the single first virtual asset.

[0114] Claim 5A The method according to claim 4A, wherein the read index includes a negative value indicating the deletion of the part of the single first virtual asset.

[0115] Claim 6A The method according to any combination of claims 3A to 5A, wherein the part of the single first virtual asset includes an asset among the first plurality of assets.

[0116] Claim 7A The method according to any combination of claims 1A to 5A, further comprising the step of compressing each of the plurality of segments to obtain a plurality of compressed segments.

[0117] Claim 8A The step of outputting the single segment includes the step of outputting the single segment only after receiving, from the user computing device, confirmation that a previously transmitted segment from the plurality of segments has been installed. The method according to any combination of claims 1A to 6A.

[0118] Claim 9A The step of segmenting the patch into a plurality of segments is obtaining device information describing the available memory size of the user computing device; A method according to any combination of claims 1A to 8A, comprising: determining the size of each segment from the plurality of segments based on the available memory size of the user computing device.

[0119] Claim 10A A method according to any combination of claims 1A to 9A, wherein at least two of the sizes of the plurality of segments are the same.

[0120] Claim 11A A method according to any combination of claims 1A to 9A, wherein the size of each segment from the plurality of segments is predefined.

[0121] Claim 12A A method according to any combination of claims 1A to 11A, wherein each of the first plurality of assets and the second plurality of assets comprises one or more of an image, a video, a texture, audio data, and video data.

[0122] Claim 13A A server computing device, a memory configured to store a first plurality of assets that form an unpatched application and a second plurality of assets that form a patched application, one or more processors, the one or more processors being configured to virtualize the first plurality of assets to obtain a single first virtual asset, configured, to obtain a single second virtual asset representing a second plurality of assets that form a patched application, configured to obtain a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset to be used in updating the single first virtual asset, the one or more processors further configured to segment the patch into a plurality of segments, a server computing device configured to output a single segment from the plurality of segments to the user computing device for individual installation on the unpatched application by the user computing device.

[0123] Item 14A The server computing device according to Item 13A, wherein the single segment includes a copy command and a write command indicating how to update the first virtual asset to obtain the single second virtual asset.

[0124] Item 15A The one or more processors further configured to generate metadata indicating when to delete a portion of the single first virtual asset, The server computing device according to any combination of Item 13A and Item 14A, configured to output the metadata to the user computing device.

[0125] Item 16A The server computing device according to Item 15A, wherein the metadata includes a read index, and the read index indicates what the cumulative memory reads during application of the plurality of segments to delete a portion of the single first virtual asset after the read index.

[0126] Item 17A The reading index is the server computing device according to item 16A, including a negative value indicating deletion of a part of the single first virtual asset.

[0127] Item 18A The part of the single first virtual asset is the server computing device according to any combination of items 15A to 17A, including an asset among the first plurality of assets.

[0128] Item 19A The one or more processors are further configured to compress each of the plurality of segments to obtain a plurality of compressed segments, which is the server computing device according to any combination of items 13A to 17A.

[0129] Item 20A The one or more processors receive from the user computing device a confirmation that a previously transmitted segment from the plurality of segments has been installed. Only then, the single segment is configured to be output, which is the server computing device according to any combination of items 13A to 18A.

[0130] Item 21A The one or more processors are configured to obtain device information describing the available memory size of the user computing device, and are configured to determine the size of each segment from the plurality of segments based on the available memory size of the user computing device, which is the server computing device according to any combination of items 13A to 20A.

[0131] Item 22A The sizes of at least two of the plurality of segments are the same, which is the server computing device according to any combination of items 13A to 21A.

[0132] Item 23A The size of each segment from the plurality of segments is a server computing device described in any combination of Items 13A to 21A, which is predefined.

[0133] Item 24A Each of the first plurality of assets and the second plurality of assets is a server computing device described in any combination of Items 13A to 23A, which includes one or more of images, videos, textures, audio data, and video data.

[0134] Item 25A A non - transitory computer - readable storage medium storing instructions, which when executed, cause one or more processors to virtualize a first plurality of assets forming an unpatched application to obtain a single first virtual asset, obtain a single second virtual asset representing a second plurality of assets forming a patched application, obtain a patch based on the difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset, and a part of the second virtual asset used for updating the single first virtual asset including , which when executed, the instructions further cause the one or more processors to segment the patch into a plurality of segments, A non - transitory computer - readable storage medium that outputs a single segment from the plurality of segments to the user computing device for individual installation of the patch on the unpatched application by the user computing device.

[0135] Item 1B A method, comprising One or more processors of a user computing device obtain a single segment out of a plurality of segments from a server computing device, where the plurality of segments represent patches, and the patch identifies how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, and the second virtualized asset used to update the single first virtualized asset includes a part of, and the method further includes the one or more processors virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset the one or more processors apply the single segment to the single first virtual asset to construct at least a part of a single second virtual asset, where the single second virtual asset includes a second plurality of assets that form the patched application.

[0136] Item 2B The method according to Item 1B, wherein the single segment includes one or more of a delete command, a copy command, and a write command indicating how to update the first virtual asset to obtain the single second virtual asset.

[0137] Item 3B obtaining metadata indicating when to delete a part of the single first virtual asset further comprising deleting a part of the single first virtual asset based on the metadata, the method according to any combination of Item 1B and Item 2B.

[0138] Item 4B The metadata includes a read index, and the read index indicates what the cumulative memory reads during the application of the plurality of segments to delete a part of the single first virtual asset after the read index. The method further includes maintaining a read counter that reflects multiple reads of the single first virtual asset during the application of the plurality of segments; and deleting the part of the single first virtual asset when the read counter is equal to the read index, the method according to item 3B.

[0139] Item 5B The read index includes a negative value indicating deletion of the part of the single first virtual asset without referring to the read counter, the method according to item 4B.

[0140] Item 6B The part of the single first virtual asset includes an asset among the first plurality of assets, the method according to any combination of items 3B to 5B.

[0141] Item 7B The patch includes a compressed patch, The method includes restoring the single segment and directly writing one of the parts of the second virtual asset to the patched application, the method according to any combination of items 1B to 5B.

[0142] Item 8B The method further includes outputting to the server computing device a confirmation that a previously transmitted segment from the plurality of segments has been installed, and the step of obtaining the single segment includes receiving the single segment in response to outputting the confirmation, the method according to any combination of items 1B to 6B.

[0143] Item 9B The method according to any combination of Items 1B to 8B, further comprising the step of deleting the single segment after applying the single segment to the single first virtual asset and before receiving a single consecutive segment among the plurality of segments.

[0144] Item 10B The step of determining that a certain part of the part of the single second virtual asset is not sufficiently provided in the single segment; In response to determining that the part is not sufficiently provided in the single segment, the step of caching the single segment; The step of requesting consecutive segments among the plurality of segments from the server computing device; In response to the request for the consecutive segments, the step of receiving the consecutive segments; The method according to any combination of Items 1B to 9B, further comprising the step of applying the single segment and the consecutive segments to the single first virtual asset to construct at least the part of the single second virtual asset.

[0145] Item 11B The step of obtaining device information describing the available memory size of the user computing device; The method according to any combination of Items 1B to 10B, further comprising the step of outputting the device information to the server computing device to enable the server computing device to determine the size of each segment from the plurality of segments.

[0146] Item 12B The method according to any combination of Items 1B to 10B, wherein at least two sizes of the plurality of segments are the same.

[0147] Item 13B The size of each segment from the plurality of segments is the method described in any combination of Items 1B to 10B, which is predefined.

[0148] Item 14B Each of the first plurality of assets and the second plurality of assets is the method described in any combination of Items 1B to 13B, and includes one or more of images, videos, textures, audio data, and video data.

[0149] Item 15B A user computing device, comprising a memory configured to store a single segment out of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing the patched application, the patches including a part of the second virtualized asset used for updating the single first virtualized asset, and the user computing device further comprising one or more processors, the one or more processors being configured to virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset, being configured to apply the single segment to the single first virtual asset to construct at least a part of a single second virtual asset, the single second virtual asset including a second plurality of assets forming the patched application, a user computing device.

[0150] Item 16B The single segment includes one or more of a delete command, a copy command, and a write command that indicate how to update the first virtual asset to obtain the single second virtual asset, the user computing device according to item 15B.

[0151] Item 17B The one or more processors are further configured to obtain metadata indicating when to delete a portion of the single first virtual asset, the user computing device according to any combination of items 15B and 16B, configured to delete a portion of the single first virtual asset based on the metadata.

[0152] Item 18B The metadata includes a read index, and the read index indicates what the cumulative memory reads during the application of the plurality of segments to delete a portion of the single first virtual asset after the read index. The one or more processors are further configured to maintain a read counter that reflects multiple reads of the single first virtual asset during the application of the plurality of segments, the user computing device according to item 17B, configured to delete the portion of the single first virtual asset when the read counter is equal to the read index.

[0153] Item 19B The user computing device according to item 18B, wherein the read index includes a negative value indicating deletion of the portion of the single first virtual asset without referring to the read counter.

[0154] Item 20B A part of the single first virtual asset includes a user computing device described in any combination of Items 17B to 19B, which includes an asset among the first plurality of assets.

[0155] Item 21B The single segment includes a single compressed segment, The one or more processors are further configured to restore the single compressed segment and directly write one of the parts of the second virtual asset to the patched application, which is a user computing device described in any combination of Items 15B to 19B.

[0156] Item 22B The one or more processors are further configured to output to the server computing device a confirmation that a previously transmitted segment from the plurality of segments has been installed, and the one or more processors are configured to receive the single segment in response to outputting the confirmation, which is a user computing device described in any combination of Items 15B to 20B.

[0157] Item 23B The one or more processors are further configured to delete the single segment after applying the single segment to the single first virtual asset and before receiving a consecutive single segment among the plurality of segments, which is a user computing device described in any combination of Items 15B to 22B.

[0158] Item 24B The one or more processors are further configured to determine that a certain part of the part of the single second virtual asset is not sufficiently provided in the single segment, In response to determining that the portion is not sufficiently provided in the single segment, configured to cache the single segment, configured to request consecutive segments of the plurality of segments from the server computing device, configured to receive the consecutive segments in response to the request for the consecutive segments, The user computing device according to any combination of items 15B to 23B, configured to apply the single segment and the consecutive segments to the single first virtual asset to construct at least the portion of the single second virtual asset.

[0159] Item 25B The one or more processors are further configured to obtain device information describing the available memory size of the user computing device, The user computing device according to any combination of items 15B to 24B, configured to output the device information to the server computing device to enable the server computing device to determine the size of each segment from the plurality of segments.

[0160] Item 26B The user computing device according to any combination of items 15B to 24B, wherein at least two sizes of the plurality of segments are the same.

[0161] Item 27B The user computing device according to any combination of items 15B to 24B, wherein the size of each segment from the plurality of segments is predefined.

[0162] Item 28B Each of the first plurality of assets and the second plurality of assets is a user computing device according to any combination of items 15B to 27B, comprising one or more of an image, a video, a texture, audio data, and video data.

[0163] Item 29B A non-transitory computer-readable storage medium storing instructions that, when executed, cause one or more processors of a user computing device to obtain a single segment of a plurality of segments from a server computing device, the plurality of segments representing patches, the patches identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, the single second virtualized asset including a portion of the first virtualized asset used to update the single first virtualized asset, and the instructions further causing, when executed, the one or more processors of the user computing device to virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset, apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets forming the patched application, the non-transitory computer-readable storage medium.

[0164] Item 1C A method comprising: virtualizing, by one or more processors, a first plurality of assets forming an unpatched application to obtain a single first virtual asset; and virtualizing, by the one or more processors, a second plurality of assets forming a patched application to obtain a single second virtual asset; The one or more processors obtain a patch based on a difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a portion of the second virtual asset used to update the single first virtual asset, the method further comprising while obtaining the patch, the one or more processors generate metadata indicating when a user computing device can delete a portion of the single first virtual asset; and outputting, by the one or more processors, the patch and the metadata to the user computing device.

[0165] Item 2C The metadata includes a read index, the read index indicating, after the read index, what the cumulative memory reads during application of the patch to delete a portion of the single first virtual asset stored by the user computing device, the method according to Item 1C.

[0166] Item 3C The method according to Item 2C, wherein the read index includes a negative value indicating deletion of the portion of the single first virtual asset stored by the user computing device.

[0167] Item 4C The method according to any combination of Items 2C and 3C, wherein the portion of the single first virtual asset includes an asset among the first plurality of assets.

[0168] Item 5C The method according to any combination of Items 1C to 4C, further comprising compressing the patch to obtain a compressed patch.

[0169] Item 6C The patch is a method according to any combination of Items 1C to 5C, including one or more of a delete command, a copy command, and a write command, indicating how to update the first virtual asset to obtain the single second virtual asset.

[0170] Item 7C The method further comprises the step of segmenting the patch into a plurality of segments, The step of outputting the patch is a method according to any combination of Items 1C to 6C, comprising the step of outputting a single segment from the plurality of segments to the user computing device for individual installation of the unpatched application on the user computing device.

[0171] Item 8C The step of outputting the single segment includes the step of outputting the single segment only after receiving, from the user computing device, confirmation that a previously transmitted segment from the plurality of segments has been installed, the method according to Item 7C.

[0172] Item 9C The step of segmenting the patch into a plurality of segments comprises the step of obtaining device information describing the available memory size of the user computing device, and the step of determining the size of each segment from the plurality of segments based on the available memory size of the user computing device, the method according to any combination of Items 7C and 8C.

[0173] Item 10C The method according to any combination of Items 6C to 9C, wherein at least two of the plurality of segments have the same size.

[0174] Item 11C The size of each segment from the plurality of segments is the method described in any combination of Items 6C to 9C, which is predefined.

[0175] Item 12C Each of the first plurality of assets and the second plurality of assets is the method described in any combination of Items 1C to 11C, and includes one or more of an image, a video, a texture, audio data, and video data.

[0176] Item 13C A server computing device, A memory configured to store a first plurality of assets that form an unpatched application and a second plurality of assets that form a patched application, Comprising one or more processors, the one or more processors are Configured to virtualize the first plurality of assets to obtain a single first virtual asset, Configured to virtualize the second plurality of assets to obtain a single second virtual asset, Configured to obtain a patch based on the difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset and including a part of the second virtual asset used for updating the single first virtual asset, and the one or more processors further Configured to generate metadata indicating when a user computing device can delete a part of the single first virtual asset while obtaining the patch, A server computing device configured to output the patch and the metadata to the user computing device.

[0177] Item 14C The metadata includes a read index, and the read index indicates what the cumulative memory reads during the application of the patch to delete a part of the single first virtual asset stored by the user computing device, as described in item 13C of the server computing device.

[0178] Item 15C The read index includes a negative value indicating the deletion of the part of the single first virtual asset stored by the user computing device, as described in item 14C of the server computing device.

[0179] Item 16C The part of the single first virtual asset includes an asset among the first plurality of assets, as described in any combination of items 14C and 15C of the server computing device.

[0180] Item 17C The one or more processors are further configured to compress the patch to obtain a compressed patch, as described in any combination of items 13C to 16C of the server computing device.

[0181] Item 18C The patch includes one or more of a delete command, a copy command, and a write command indicating how to update the first virtual asset to obtain the single second virtual asset, as described in any combination of items 13C to 17C of the server computing device.

[0182] Item 19C The one or more processors are further configured to segment the patch into a plurality of segments, The one or more processors are configured to output a single segment from the plurality of segments to the user computing device for individual installation of the unpatched application by the user computing device, the server computing device according to any combination of clauses 13C to 18C.

[0183] Clause 20C The one or more processors are configured to output the single segment only after receiving, from the user computing device, confirmation that a previously transmitted segment from the plurality of segments has been installed, the server computing device according to clause 19C.

[0184] Clause 21C The one or more processors are configured to obtain device information describing the available memory size of the user computing device, and configured to determine the size of each segment from the plurality of segments based on the available memory size of the user computing device, the server computing device according to any combination of clauses 19C and 20C.

[0185] Clause 22C At least two of the sizes of the plurality of segments are the same, the server computing device according to any combination of clauses 18C to 21C.

[0186] Clause 23C The size of each segment from the plurality of segments is predefined, the server computing device according to any combination of clauses 18C to 21C.

[0187] Clause 24C Each of the first plurality of assets and the second plurality of assets is a server computing device according to any combination of items 13C to 23C, comprising one or more of images, videos, textures, audio data, and video data.

[0188] Item 25C A non-transitory computer-readable storage medium storing instructions that, when executed, cause one or more processors to virtualize a first plurality of assets that form an unpatched application to obtain a single first virtual asset, virtualize a plurality of assets that form a patched application to obtain a single second virtual asset, obtain a patch based on the difference between the single first virtual asset and the single second virtual asset, the patch identifying how to update the first virtual asset to obtain the single second virtual asset, and a portion of the second virtual asset used to update the single first virtual asset including wherein the instructions further cause the one or more processors to, when executed, generate metadata indicating when a user computing device can delete a portion of the single first virtual asset while obtaining the patch, A non-transitory computer-readable storage medium that outputs the patch and the metadata to the user computing device.

[0189] Item 1D A method comprising: one or more processors of a user computing device obtaining a patch from a server computing device, the patch identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application including a portion of the second virtualized asset used to update the single first virtualized asset, the method further comprising: obtaining, by the one or more processors, from the server computing device, metadata indicating when the user computing device can delete a portion of the single first virtual asset; virtualizing, by the one or more processors, a first plurality of assets that form the unpatched applications installed on the user computing device to obtain the single first virtual asset; applying, by the one or more processors, the patch to the single first virtual asset to construct the single second virtual asset, the single second virtual asset including a second plurality of assets that form the patched applications, the method further comprising: during application of the patch, based on the metadata, deleting the portion of the single first virtual asset.

[0190] Item 2D The method according to Item 1D, wherein the patch includes one or more of a delete command, a copy command, and a write command indicating how to update the first virtual asset to obtain the single second virtual asset.

[0191] Item 3D The metadata includes a read index, the read index indicating, after the read index, what the cumulative memory reads during application of the patch to delete the portion of the single first virtual asset. During application of the patch, the step of deleting the portion of the single first virtual asset comprises: maintaining, during application of the patch, a read counter that reflects multiple reads of the single first virtual asset; The method according to any combination of claims 1D and 2D, comprising the step of deleting a part of the single first virtual asset when the read counter is equal to the read index.

[0192] Claim 4D The method according to claim 3D, wherein the read index includes a negative value indicating deletion of a part of the single first virtual asset without referring to the read counter.

[0193] Claim 5D The method according to any combination of claims 1D to 4D, wherein the part of the single first virtual asset includes an asset among the first plurality of assets.

[0194] Claim 6D The patch includes a compressed patch, The method according to any combination of claims 1D to 5D, comprising the step of restoring the patch and directly writing one of the parts of the second virtual asset to the patched application.

[0195] Claim 7D The step of obtaining the patch includes the step of obtaining a single segment among a plurality of segments, and the plurality of segments represent the patch, The step of applying the patch includes applying the single segment to the single first virtual asset to construct at least a part of the single second virtual asset. The method according to any combination of claims 1D to 6D.

[0196] Claim 8D The method according to claim 7D, further comprising the step of outputting to the server computing device a confirmation that a previously transmitted segment from the plurality of segments has been installed, and the step of obtaining the single segment includes receiving the single segment in response to outputting the confirmation.​

[0197] Item 9D The method according to any combination of Items 7D and 8D, further comprising the step of deleting the single segment after applying the single segment to the single first virtual asset and before receiving a single consecutive segment among the plurality of segments.

[0198] Item 10D The step of determining that a certain part of the part of the single second virtual asset is not sufficiently provided in the single segment, and In response to determining that the part is not sufficiently provided in the single segment, the step of caching the single segment, and The step of requesting consecutive segments among the plurality of segments from the server computing device, and In response to the request for the consecutive segments, the step of receiving the consecutive segments, and The method according to any combination of Items 7D to 9D, further comprising the step of applying the single segment and the consecutive segments to the single first virtual asset to construct at least the part of the single second virtual asset.

[0199] Item 11D The step of obtaining device information describing the available memory size of the user computing device, and The method according to any combination of Items 7D to 10D, further comprising the step of outputting the device information to the server computing device to enable the server computing device to determine the size of each segment from the plurality of segments.

[0200] Item 12D The method according to any combination of Items 7D to 10D, wherein at least two sizes of the plurality of segments are the same.

[0201] Item 13D The size of each segment from the plurality of segments is in accordance with a method described in any combination of Items 7D to 10D, which is predefined.

[0202] Item 14D Each of the first plurality of assets and the second plurality of assets includes one or more of images, videos, textures, audio data, and video data, in accordance with a method described in any combination of Items 1D to 13D.

[0203] Item 15D A user computing device, comprising a memory configured to store a patch, the patch identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing the patched application, and including a portion of the second virtualized asset used for updating the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors being configured to apply the patch to the single first virtual asset to construct the single second virtual asset, the single second virtual asset including a second plurality of assets forming the patched application, the one or more processors further being configured to delete a portion of the single first virtual asset based on metadata during application of the patch, a user computing device.

[0204] Item 16D The user computing device according to Item 15D, wherein the patch includes one or more of a delete command, a copy command, and a write command indicating how to update the first virtual asset to obtain the single second virtual asset.

[0205] Item 17D The metadata includes a read index, and the read index indicates what the cumulative memory reads during the application of the patch to delete the part of the single first virtual asset after the read index. During the application of the patch, the step of deleting the part of the single first virtual asset includes maintaining a read counter that reflects multiple reads of the single first virtual asset during the application of the patch; and when the read counter is equal to the read index, deleting the part of the single first virtual asset, the method according to any combination of Items 15D and 16D.

[0206] Item 18D The user computing device according to Item 17D, wherein the read index includes a negative value indicating deletion of the part of the single first virtual asset without referring to the read counter.

[0207] Item 19D The user computing device according to any combination of Items 15D to 18D, wherein the part of the single first virtual asset includes an asset among the first plurality of assets.

[0208] Item 20D The single segment includes a single compressed segment, The user computing device according to any combination of Items 15D to 19D, wherein the one or more processors are configured to restore the single compressed patch and directly write one of the parts of the second virtual asset to the patched application.

[0209] Item 21D The one or more processors obtain a single segment among the plurality of segments configured to represent the patch, and the plurality of segments represent the patch, the one or more processors are configured to apply the single segment to the single first virtual asset to construct at least the part of the single second virtual asset, according to any combination of claims 15D to 20D, the user computing device described.

[0210] Item 22D the one or more processors are further configured to output to the server computing device a confirmation that a previously transmitted segment from the plurality of segments has been installed, obtaining the single segment comprises receiving the single segment in response to outputting the confirmation, according to Item 21D, the user computing device described.

[0211] Item 23D the one or more processors are further configured to delete the single segment after applying the single segment to the single first virtual asset and before receiving a consecutive single segment among the plurality of segments, according to any combination of Items 21D and 22D, the user computing device described.

[0212] Item 24D the one or more processors are further configured to, determine that a certain part of the part of the single second virtual asset is not sufficiently provided by the single segment, in response to determining that the part is not sufficiently provided by the single segment, configure to cache the single segment, configure to request consecutive segments among the plurality of segments from the server computing device, in response to the request for the consecutive segments, configure to receive the consecutive segments, A user computing device according to any combination of clauses 21D to 23D, configured to apply the single segment and the continuous segments to the single first virtual asset to construct at least the portion of the single second virtual asset.

[0213] Clause 25D The one or more processors are further configured to obtain device information describing the available memory size of the user computing device, and output the device information to the server computing device to enable the server computing device to determine the size of each segment from the plurality of segments. A user computing device according to any combination of clauses 21D to 24D.

[0214] Clause 26D A user computing device according to any combination of clauses 21D to 24D, wherein at least two of the sizes of the plurality of segments are the same.

[0215] Clause 27D The size of each segment from the plurality of segments is predefined. A user computing device according to any combination of clauses 21D to 24D.

[0216] Clause 28D Each of the first plurality of assets and the second plurality of assets includes one or more of an image, a video, a texture, audio data, and video data. A user computing device according to any combination of clauses 15D to 27D.

[0217] Clause 29D A non-transitory computer-readable storage medium storing instructions that, when executed, cause one or more processors of a user computing device to obtain a patch from a server computing device, the patch identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, the patch including a portion of the second virtualized asset used to update the single first virtualized asset, the instructions further causing, when executed, the one or more processors of the user computing device to virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset, apply the patch to the single first virtual asset to construct the single second virtual asset, the single second virtual asset including a second plurality of assets that form the patched application, the instructions further causing, when executed, the one or more processors of the user computing device to delete a portion of the single first virtual asset based on the metadata during application of the patch, a non-transitory computer-readable storage medium.

[0218] In one or more examples, the described functions may be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functions may be stored on or transmitted via a computer-readable medium as one or more instructions or code and executed by a hardware-based processing unit. The computer-readable medium may include a computer-readable storage medium, which may be a tangible medium such as a data storage medium, or a communication medium that supports the transfer of a computer program from one place to another, for example, according to a communication protocol. Thus, the computer-readable medium generally corresponds to (1) a tangible computer-readable storage medium that is non-transitory, or (2) a communication medium such as a signal or carrier wave. The data storage medium may be any available medium that can be accessed by one or more computers or one or more processors to retrieve instructions, code, and / or data structures for implementing the techniques described in this disclosure. A computer program product may include a computer-readable medium.

[0219] By way of example and not limitation, such computer-readable storage media may comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage, or other magnetic storage devices, flash memory, or other media that can be used to store the desired program code in the form of instructions or data structures and that can be accessed by a computer. Also, any connection is suitable for calling a computer-readable medium. For example, coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technology (such as infrared, wireless, and microwave) may be used to connect a website, server, or other remote When instructions are sent from an auto source, coaxial cables, fiber optic cables, twisted pairs, DSL, or wireless technologies (such as infrared, radio, and microwave) are included in the definition of the medium. However, it should be understood that computer-readable storage media and data storage media do not include connections, carrier waves, signals, or other transient media, but instead target non-transitory tangible storage media. As used herein, disk and disc include compact discs (CDs), laser discs, optical discs, digital versatile discs (DVDs), floppy discs, and Blu-ray discs, where disk typically magnetically reproduces data and disc optically reproduces data using a laser. Combinations of the above should also be included within the scope of computer-readable media.

[0220] Instructions may be executed by one or more processors (such as one or more digital signal processors (DSPs), general-purpose microprocessors, application-specific integrated circuits (ASICs), field-programmable logic arrays (FPGAs), or other equivalent integrated or discrete logic circuits). Thus, as used herein, the term "processor" may mean any of the above structures or other structures suitable for implementing the techniques described herein. Also, in some aspects, the functions described herein may be provided within dedicated hardware and / or software modules. Additionally, these techniques may be fully implemented in one or more circuits or logic elements.

[0221] The techniques of the present disclosure may be implemented in a variety of devices or apparatuses, including wireless handsets, integrated circuits (ICs), or a set of ICs (e.g., a chipset). Although various components, modules, or units are described in the present disclosure to highlight the functional aspects of devices configured to execute the disclosed techniques, implementation by various hardware units is not necessarily required. Rather, as described above, the various units may be combined within a hardware unit or provided by an assembly of interoperable hardware units including one or more of the above processors, along with suitable software and / or firmware.

[0222] Various aspects of the present disclosure have been described. These and other aspects are within the scope of the following claims.

Claims

1. A method comprising: one or more processors of a user computing device obtaining a single segment of a plurality of segments from a server computing device, the plurality of segments representing patches, the patches identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, the single second virtualized asset including a portion of the second virtualized asset used to update the single first virtualized asset, the method further comprising: the one or more processors virtualizing a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset; the one or more processors applying the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form the patched application, the method further comprising: obtaining metadata indicating when to delete a portion of the single first virtual asset, the metadata including a read index, the read index indicating what the cumulative memory reads during application of the plurality of segments to delete a portion of the single first virtual asset after the read index, the method further comprising: maintaining a read counter that reflects multiple reads of the single first virtual asset during application of the plurality of segments; deleting the portion of the single first virtual asset when the read counter is equal to the read index.

2. The method of claim 1, wherein the single segment includes one or more of a delete command, a copy command, and a write command indicating how to update the first virtual asset to obtain the single second virtual asset.

3. The method according to claim 1 or 2, wherein the read index includes a negative value indicating deletion of a part of the single first virtual asset without referring to the read counter. **Claim 4**: A method comprising: one or more processors of a user computing device obtaining a single segment of a plurality of segments from a server computing device, the plurality of segments representing patches, the patches identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing the patched application, the single second virtualized asset including a part of the second virtualized asset used to update the single first virtualized asset, the method further comprising: the one or more processors virtualizing a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset; the one or more processors applying the single segment to the single first virtual asset to construct at least a part of a single second virtual asset, the single second virtual asset including a second plurality of assets forming the patched application, the method further comprising: obtaining metadata indicating when to delete a part of the single first virtual asset; further comprising deleting a part of the single first virtual asset based on the metadata; wherein the part of the single first virtual asset includes an asset among the first plurality of assets. **Claim 5**: A method comprising: One or more processors of a user computing device obtain a single segment out of a plurality of segments from a server computing device, the plurality of segments represent patches, the patches identify how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application, the patches include a part of the second virtualized asset used to update the single first virtualized asset, and the method further comprises the one or more processors virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset the one or more processors apply the single segment to the single first virtual asset to construct at least a part of a single second virtual asset, the single second virtual asset including a second plurality of assets forming a patched application the patch includes a compressed patch The method includes restoring the single segment and writing one of the parts of the second virtual asset directly to the patched application. **Claim 6**: A method One or more processors of a user computing device obtain a single segment out of a plurality of segments from a server computing device, the plurality of segments represent patches, the patches identify how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application, the patches include a part of the second virtualized asset used to update the single first virtualized asset, and the method further comprises the one or more processors virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset the one or more processors apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application, the method further comprising, outputting, by the server computing device, a confirmation that a previously transmitted segment from the plurality of segments has been installed, the obtaining of the single segment including receiving the single segment in response to outputting the confirmation. **Claim 7.** A method, comprising: one or more processors of a user computing device obtain a single segment from a plurality of segments, the plurality of segments representing patches, the patches identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application, the single second virtualized asset including a portion to be used to update the single first virtualized asset, the method further comprising, the one or more processors virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset; and the one or more processors apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application, the method further comprising, after applying the single segment to the single first virtual asset, deleting the single segment before receiving a successive single segment of the plurality of segments. **Claim 8.** A method, comprising: One or more processors of a user computing device obtain a single segment out of a plurality of segments from a server computing device, the plurality of segments represent patches, the patches identify how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application, and the patches include a portion of the second virtualized asset used to update the single first virtualized asset. The method further includes One or more processors virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset; One or more processors apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets forming a patched application. The method further includes Determining that a portion of the portion of the single second virtual asset is not sufficiently provided by the single segment; In response to determining that the portion is not sufficiently provided by the single segment, caching the single segment; Requesting a consecutive segment from the plurality of segments from the server computing device; Receiving the consecutive segment in response to the request for the consecutive segment; Further comprising applying the single segment and the consecutive segment to the single first virtual asset to construct at least the portion of the single second virtual asset. A method. **Claim 9**: A method, comprising One or more processors of a user computing device obtain a single segment out of a plurality of segments from a server computing device, the plurality of segments represent patches, the patch identifies how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application, the patch includes a portion of the second virtualized asset used to update the single first virtualized asset, and the method further includes One or more processors virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset One or more processors apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset includes a second plurality of assets that form a patched application, and the method further includes Obtaining device information describing the available memory size of the user computing device Outputting the device information to the server computing device to enable the server computing device to determine the size of each segment from the plurality of segments, the method further comprising Claim 10. A method comprising One or more processors of a user computing device obtain a single segment out of a plurality of segments from a server computing device, the plurality of segments represent patches, the patch identifies how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application, the patch includes a portion of the second virtualized asset used to update the single first virtualized asset, and the method further includes The step of the one or more processors virtualizing a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset; The method comprising: the step of the one or more processors applying the single segment to the single first virtual asset to construct at least a part of a single second virtual asset, the single second virtual asset including a second plurality of assets forming a patched application, and at least two of the plurality of segments having the same size. **Claim 11**: A method, Comprising the step of one or more processors of a user computing device obtaining a single segment from among a plurality of segments, the plurality of segments representing patches, the patches identifying how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application, and including a part of the second virtualized asset used for updating the single first virtualized asset, the method further comprising: The step of the one or more processors virtualizing a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset; The method comprising: the step of the one or more processors applying the single segment to the single first virtual asset to construct at least a part of a single second virtual asset, the single second virtual asset including a second plurality of assets forming a patched application, and the size of each segment from the plurality of segments being predefined. **Claim 12**: A method, One or more processors of a user computing device obtain a single segment out of a plurality of segments from a server computing device, the plurality of segments represent patches, the patches identify how to update a first virtualized asset representing an unpatched application to obtain a single second virtualized asset representing a patched application, the patches include a portion of the second virtualized asset used to update the single first virtualized asset, and the method further comprises one or more processors virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset; one or more processors apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset includes a second plurality of assets forming a patched application, and each of the first plurality of assets and the second plurality of assets includes one or more of an image, video, texture, audio data, and video data. **Claim 13** A user computing device, comprising a memory configured to store a single segment out of a plurality of segments provided by a server computing device, the plurality of segments represent patches, the patches identify how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing a patched application, the patches include a portion of the second virtualized asset used to update the single first virtualized asset, and the user computing device further comprises one or more processors, the one or more processors virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset; configured to apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application, the one or more processors further configured to obtain metadata indicating when to delete a portion of the single first virtual asset, the metadata including a read index, the read index indicating, after the read index, what the cumulative memory reads during application of the plurality of segments to delete a portion of the single first virtual asset, the one or more processors further maintaining a read counter that reflects multiple reads of the single first virtual asset during application of the plurality of segments A user computing device configured to delete the portion of the single first virtual asset when the read counter is equal to the read index.

14. The user computing device according to claim 13, wherein the single segment includes one or more of a delete command, a copy command, and a write command indicating how to update the first virtual asset to obtain the single second virtual asset.

15. The user computing device according to claim 13 or 14, wherein the read index includes a negative value indicating deletion of the portion of the single first virtual asset without referring to the read counter.

16. A user computing device, comprising a memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing a patch, the patch identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing a patched application, the portion of the second virtualized asset used in updating the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors being configured to virtualize a first plurality of assets that form the unpatched applications installed on the user computing device to obtain the single first virtual asset; and apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application, the one or more processors further being configured to obtain metadata indicating when to delete a portion of the single first virtual asset; and 、 delete a portion of the single first virtual asset based on the metadata, wherein the portion of the single first virtual asset includes assets among the first plurality of assets, and the user computing device. **Claim 17.** A user computing device, comprising a memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing a patched application, the portion of the single second virtual asset being used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors being configured to virtualize a first plurality of assets that form the unpatched applications installed on the user computing device to obtain the single first virtual asset; and apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application, wherein the single segment includes a single compressed segment. The one or more processors are further configured to restore the single compressed segment and write one of the portions of the second virtual asset directly to the patched application, a user computing device. **Claim 18**: A user computing device, comprising: a memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing the patched application, the single second virtual asset including a portion of the second virtualized asset used to update the single first virtualized asset, the user computing device further comprising: one or more processors, the one or more processors being configured to: virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset; and apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form the patched application; The one or more processors are further configured to output to the server computing device a confirmation that a previously transmitted segment from the plurality of segments has been installed, and to receive the single segment in response to outputting the confirmation, a user computing device. **Claim 19**: A user computing device, comprising: A memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing a patched application, the single second virtual asset including a portion of the second virtualized asset used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset; and configured to apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets forming a patched application, The one or more processors are further configured to delete the single segment before receiving a consecutive single segment of the plurality of segments after applying the single segment to the single first virtual asset, a user computing device. **Claim 20** A user computing device, A memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing a patched application, the single second virtual asset including a portion of the second virtualized asset used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors Virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset; configured to apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application; The one or more processors further determine that a portion of the portion of the single second virtual asset is not sufficiently provided by the single segment; in response to determining that the portion is not sufficiently provided by the single segment, cache the single segment; request a contiguous segment of the plurality of segments from the server computing device; receive the contiguous segment in response to the request for the contiguous segment; configured to apply the single segment and the contiguous segment to the single first virtual asset to construct at least the portion of the single second virtual asset, a user computing device. **Claim 21**: A user computing device, comprising a memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing a patched application, the portion of the second virtualized asset being used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors virtualize a first plurality of assets that form the unpatched application installed on the user computing device to obtain the single first virtual asset; configured to apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application, the one or more processors are further configured to obtain device information describing the available memory size of the user computing device, output the device information to the server computing device to enable the server computing device to determine the size of each segment from the plurality of segments, a user computing device. **Claim 22** A user computing device, comprising a memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing the patched application, and including a portion of the second virtualized asset used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors being configured to virtualize a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset, apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application, a user computing device, wherein at least two of the plurality of segments have the same size. **Claim 23** A user computing device, A memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing a patched application, the single second virtual asset including a portion of the second virtualized asset used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors virtualizing a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset, applying the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets forming a patched application, The size of each segment from the plurality of segments is predefined, user computing device. **Claim 24** A user computing device, A memory configured to store a single segment of a plurality of segments provided by a server computing device, the plurality of segments representing patches, the patches identifying how to update a single first virtual asset representing an unpatched application to obtain a single second virtual asset representing a patched application, the single second virtual asset including a portion of the second virtualized asset used to update the single first virtualized asset, the user computing device further comprising one or more processors, the one or more processors virtualizing a first plurality of assets forming the unpatched application installed on the user computing device to obtain the single first virtual asset, configured to apply the single segment to the single first virtual asset to construct at least a portion of a single second virtual asset, the single second virtual asset including a second plurality of assets that form a patched application, each of the first plurality of assets and the second plurality of assets including one or more of images, videos, textures, audio data, and video data, a user computing device.

25. A program that causes one or more processors of a user computing device to execute the method according to any one of Claims 1 to 12.

Images