{"id":103426,"date":"2020-02-10T07:00:00","date_gmt":"2020-02-10T15:00:00","guid":{"rendered":"http:\/\/devblogs.microsoft.com\/oldnewthing\/?p=103426"},"modified":"2020-09-11T15:11:22","modified_gmt":"2020-09-11T22:11:22","slug":"20200210-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20200210-00\/?p=103426","title":{"rendered":"Survey of Windows update formats: The Full update"},"content":{"rendered":"

In August 2018, Microsoft announced a new design for how updates are delivered<\/a>. How did they manage to get the size of the updates so much smaller while simultaneously reducing memory usage and update negotiation time?<\/p>\n

To understand what changed, you first need to understand how things were.<\/p>\n

Let’s focus only on changes that apply to a specific major release of Windows. (You can repeat the exercise for each major release.) Let’s call the initial release M0<\/i>. And suppose there have been five monthly cumulative updates, call then M1<\/i>, M2<\/i>, M3<\/i>, M4<\/i>, and M5<\/i> (the latest version).<\/p>\n

There are two general mechanisms that Windows Update uses to update a file: One way is to send an entire replacement file. Another is to send a patch (sometimes called a delta<\/i>) that updates the file currently on the system to the latest version.<\/p>\n

There are obvious trade-offs here. The full file works regardless of what version the customer is upgrading from, whereas the patch works only if the customer has the specific version that the patch was designed to upgrade. On the other hand, the full file is large, whereas the patch is much smaller.<\/p>\n\n\n\n\n\n
\u00a0<\/th>\nFull file<\/th>\nPatch<\/th>\n<\/tr>\n
Size<\/th>\nLarge<\/td>\nSmall<\/td>\n<\/tr>\n
Applicability<\/th>\nCan update any version<\/td>\nCan update only one version<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Suppose that the file F<\/code> was updated in M1 and M2, was unchanged in M3, and was updated again in M4 and M5. Here are all the possible full files and patch combinations.<\/p>\n\n\n\n\n\n\n\n\n\n
Update<\/th>\nFull file<\/th>\nPatch base<\/th>\n<\/tr>\n
M0<\/th>\nM1<\/th>\nM2<\/th>\nM3<\/th>\nM4<\/th>\n<\/tr>\n
M1<\/th>\nM1<\/td>\nM0 to M1<\/td>\n <\/td>\n <\/td>\n <\/td>\n <\/td>\n<\/tr>\n
M2<\/th>\nM2<\/td>\nM0 to M2<\/td>\nM1 to M2<\/td>\n <\/td>\n <\/td>\n <\/td>\n<\/tr>\n
M3<\/th>\n <\/td>\n <\/td>\n <\/td>\n <\/td>\n <\/td>\n <\/td>\n<\/tr>\n
M4<\/th>\nM4<\/td>\nM0 to M4<\/td>\nM1 to M4<\/td>\nM2 to M4<\/td>\n <\/td>\n <\/td>\n<\/tr>\n
M5<\/th>\nM5<\/td>\nM0 to M5<\/td>\nM1 to M5<\/td>\nM2 to M5<\/td>\n <\/td>\nM4 to M5<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Note that the rows and columns for M3 are empty because there was no change to F<\/code> in M3. Updating to M3 is the same as updating to M2.<\/p>\n

The simplest kind of update is the Full update<\/b>. It contains a copy of every component that has changed since the last major release. In our example, this would be the components that changed between M0 and M5. It guarantees that you can get from any version to the latest version, but it’s also very large (around 1GB<\/a>).<\/p>\n

For the file F<\/code>, the corresponding Full updates would contain the files from the Full file<\/b> column.<\/p>\n\n\n\n\n\n\n\n\n\n
Update<\/th>\nFull file<\/th>\nPatch base<\/th>\n<\/tr>\n
M0<\/th>\nM1<\/th>\nM2<\/th>\nM3<\/th>\nM4<\/th>\n<\/tr>\n
M1<\/th>\n\n
M1<\/div>\n<\/td>\n
M0 to M1<\/span><\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
M2<\/th>\n\n
M2<\/div>\n<\/td>\n
M0 to M2<\/span><\/td>\nM1 to M2<\/span><\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
M3<\/th>\n\n
\u00a0<\/div>\n<\/td>\n
\u00a0<\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
M4<\/th>\n\n
M4<\/div>\n<\/td>\n
M0 to M4<\/span><\/td>\nM1 to M4<\/span><\/td>\nM2 to M4<\/span><\/td>\n\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
M5<\/th>\n\n
M5<\/div>\n<\/td>\n
M0 to M5<\/span><\/td>\nM1 to M5<\/span><\/td>\nM2 to M5<\/span><\/td>\n\u00a0<\/td>\nM4 to M5<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The breakdown of files for Full updates is as follows:<\/p>\n\n\n\n\n\n\n\n\n
Full update<\/th>\nContents<\/th>\n<\/tr>\n
M1<\/th>\nM1<\/td>\n<\/tr>\n
M2<\/th>\nM2<\/td>\n<\/tr>\n
M3<\/th>\nM2<\/td>\n<\/tr>\n
M4<\/th>\nM4<\/td>\n<\/tr>\n
M5<\/th>\nM5<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Note that Full update M3 contains a copy of F<\/code> from M2. That way, if somebody currently running M1 needs to update to M3, the Full update will get them the M2 version of the file, which is the correct version for a system that has been updated to M3.<\/p>\n

Feature summary of Full updates:<\/p>\n