Abstract: Content rendered for display on a first client device can be referenced for similar pages to be displayed on other client devices such that similar content does not need to be re-rendered. Each client can have a respective virtual rendering engine on a host device, and the content rendered by those virtual engines can be mapped and used to generate content trees for different pages or other groupings of content. When a new page is to be rendered, the tiles or other portions matching previously-rendered tiles can be referenced, so that only new or unique portions need to be rendered for a particular page. The content can come from multiple locations as rendered by multiple virtual clients, such that for many clients the respective virtual engine may not render any content but instead reference rendered content from one or more locations as determined according to the page tree.

Abstract: A technology is described for recovering from a program exception. An example method may include detecting an occurrence of a program exception while rendering electronic content using an application that results in the application to stop rendering the electronic content. An execution history associated with the rendering of the electronic content may be analyzed to identify a failed executable object and a rendering component utilized by the failed executable object to render the electronic content may be identified. A determination may then be made whether the rendering of the electronic content may be recoverable by analyzing the failed executable object. A new executable object may then be constructed and may be associated with the rendering component utilized by the failed executable object as a result of a determination that the rendering of the electronic content may be recoverable, and rendering of the electronic content may be restarted.

Abstract: Features are disclosed for storing content items, such as content pages, applications, and other network-accessible content, such that changes to the state of the content items may be retained and restored at a later time. Storing content items can include serializing the memory state of individual portions of the content items to a persistent storage medium based on a determination that the memory state has changed since the last serialization process. The serialized content items may later be de-serialized and restored to the same memory state that they had prior to serialization. In this way, the de-serialized content items reflect changes made after they were initially retrieved and prior to serialization.

Abstract: Techniques described and suggested herein include systems and methods for updating applications by reconfiguring an active original application to serve as a proxy for an active replacement application. An original application may be initialized in a way that allows updates to the original application to occur without adversely affecting the operation of the original application. A replacement application may be configured to connect to one or more communication endpoints via the active original application.

Abstract: Debugging information for content rendered for display on a client device can be included in one or more watermarks inserted into the content. Performance, state, configuration, debugging, and other information can be encoded into a watermark and placed in rendered content in such a way that the information is imperceptible to most users. When a user reports a potential issue or problem, the user (or another source) can provide a version of the image frame corresponding to the issue, which enables the watermark to be located and the data extracted. A checksum or other value can be used to ensure that a complete and valid watermark was obtained. The data extracted from the watermark can then be used to attempt to identify and/or diagnose the potential issue without having to have access to the client device or communication with the user.

Abstract: Server systems are disclosed that retrieve content on behalf of client devices and compress the retrieved content based on information known to be available to the client devices. The server systems may use server-side copies of compression dictionaries stored on the client devices. The compression dictionaries may be based on content portions, scripts, formatting data, and other byte sequences typically found in content. In some embodiments, device-specific, browser-specific, or user-specific compression dictionaries may be used based on content requested by the respective devices/browsers/users, and the server systems may maintain server-side copies of each dictionary. During compression, the server systems may generate additional compression information, such as new compression dictionary entries, and may provide information to the clients about the differences between the server-side and client-side compression dictionaries to so that the client devices can update the client-side compression dictionaries.

Abstract: Techniques described and suggested herein include systems and methods for logging execution of code using thread-local output buffers. For example, one or more output buffers are allocated to one or more threads executing on a computing system. A global declaration list containing information relating to log types (e.g., verbose log descriptions, templates for specific variables, and the like) may be implemented, and the global declaration list may be generated as part of an initialization process for some or all of the threads. Log events from executing threads may be stored in the output buffers in a fashion conforming to the global declaration list, and may be retrieved asynchronously relative to the executing threads.

Abstract: Features are disclosed for predicting or otherwise determining when a user will initiate an operation on a user computing device, such as requesting network-accessible content. Upon making the determination, the user computing device can proactively perform the determined operation or portions thereof. The user computing device may use a detection model or profile that associates user-initiated operations with data from sensors on the user computing device. The sensors may include movement sensors, environmental sensors, and the like. One benefit, among others, is that user-perceived performance can be improved because some or all of a user-initiated operation has been performed prior to user-initiation of the operation.

Abstract: Debugging information for content rendered for display on a client device can be included in one or more watermarks inserted into the content. Performance, state, configuration, debugging, and other information can be encoded into a watermark and placed in rendered content in such a way that the information is imperceptible to most users. When a user reports a potential issue or problem, the user (or another source) can provide a version of the image frame corresponding to the issue, which enables the watermark to be located and the data extracted. A checksum or other value can be used to ensure that a complete and valid watermark was obtained. The data extracted from the watermark can then be used to attempt to identify and/or diagnose the potential issue without having to have access to the client device or communication with the user.

Abstract: Systems and methods are described for utilizing script chunks in client-side browsing applications. A script chunking service divides scripts into smaller portions, and generates precompiled chunks of code that correspond to the portions. The service may then request compilation of only those portions of a script that do not have a corresponding precompiled chunk. Portions may be determined based on length, script keywords, or other criteria, and chunks may be identified by applying a hashing function to the portions. Scripts may be filtered to identify differing portions of source code that compile to functionally identical instructions, and the chunking service may use supplemental hashes, hashes of hashes, and complier state information to facilitate identification and compilation of precompiled chunks.

Abstract: A browser divides content pages into tiles for display on a user device, and updates the tiles that become “damaged” as the result of user interactions or other events. The browser may decide whether and/or when to update a damaged off-screen tile based partly or wholly on a predicted likelihood that the user will scroll to that tile or that the tile will otherwise become visible on the user device. This prediction may, for example, be based on one or more of the following: (1) the distance of the off-screen tile from the visible display area, (2) the past browsing/scrolling behaviors of the user and/or other users. The decision of whether or when to update the damaged off-screen tile may also be based on the cost (in terms of processing resources) of updating the tile, as may be estimated based on the processing resources used to initially generate the tile. In addition, the decision may be based on a measure of visual impact associated with deferring the update.

Abstract: Techniques and solutions are described for throttling automated polling requests. For example, an automated polling request that is generated by a web page can be received and a decision can be made to throttle, or not throttle, the automated polling request. The decision can be made based on comparison of the automated polling request with previous automated polling requests (e.g., during a throttling time period). For example, repetitive automated polling requests that occur during a throttling time period can be throttled.

Abstract: A system and method for providing a print formatted string wherein a format object is created for a format string a format string having a set of format specifiers, an amount of memory to allocate to a string buffer for the format object is determined, and the determined amount of memory is allocated to the string buffer. For each set of parameter values received with the format object, where each parameter value corresponds to a format specifier in the format string, a determination is made whether the determined amount of memory for the string buffer is sufficient to hold the set of input parameter values in accordance with the format string. If the determined amount of memory is insufficient, an amount of memory sufficient for the set of input parameter values in accordance with the format string is re-determined, and the string buffer is reallocated to the re-determined amount of memory.

Abstract: Techniques described and suggested herein include systems and methods for logging execution of code using thread-local output buffers. For example, one or more output buffers are allocated to one or more threads executing on a computing system. A global declaration list containing information relating to log types (e.g., verbose log descriptions, templates for specific variables, and the like) may be implemented, and the global declaration list may be generated as part of an initialization process for some or all of the threads. Log events from executing threads may be stored in the output buffers in a fashion conforming to the global declaration list, and may be retrieved asynchronously relative to the executing threads.

Abstract: Context information associated with asynchronous tasks executing in a multithread computer processing environment can be captured. An identifier block having context information associated with tasks executed in the thread is stored in a call stack of a thread. For asynchronous tasks that execute in the thread, a context trace component causes the thread to place an identifier block in the stack of the thread. The identifier block stores context information associated with the currently executing task and with one or more previously executed tasks. Context information currently stored in an identifier block can be retrieved and stored in subsequent identifier blocks, thereby enabling capture of a sequential context trace of asynchronous tasks that execute in the thread. The context trace information stored in the identifier block can be retrieved to support failure analysis when a task fails to execute properly.

Abstract: Provided are systems and methods for a first process for writing messages to a shared memory (each of the messages being written to a respective buffer of the shared memory, and the messages configured to be read in a specified sequence by a second process), determining that writing of one of the messages to the shared memory has been completed and, sending, to the second process and in response to determining that writing of one of the messages to the shared memory has been completed, an offset value corresponding to a location in the shared memory, wherein the second process is configured to read one or more messages that are stored in the portion of the shared memory before the offset value. Also the second process reads one or more messages stored in buffers that reside in the portion of the shared memory before the offset value, and commits the reads.

Abstract: Techniques described and suggested herein include systems and methods for logging execution of code using thread-local output buffers. For example, one or more output buffers are allocated to one or more threads executing on a computing system. A global declaration list containing information relating to log types (e.g., verbose log descriptions, templates for specific variables, and the like) may be implemented, and the global declaration list may be generated as part of an initialization process for some or all of the threads. Log events from executing threads may be stored in the output buffers in a fashion conforming to the global declaration list, and may be retrieved asynchronously relative to the executing threads.

Abstract: Features are disclosed for dividing content pages into sections, or “tiles,” that can be updated independently of one another, and determining the processing burdens associated with updating and managing such divided content pages, the likelihood that portions of the content pages will change, etc. The processing burdens may be based on an analysis of how long it takes to update the display of the tiles or other sections of the content page, the computer memory used to update the display, the processor cycles used to update the display, etc. A browser application or some other module can use the determined processing burdens and/or change likelihoods to define a new or updated layout for dividing the content pages into tiles. The browser application may also cache, for future use, cost information and/or information regarding the new or updated layout for dividing the content pages into tiles.

Abstract: Techniques and solutions are described for multi-threaded processing of data, which may include dividing incoming data content stream into a plurality of fragments, for processing by a corresponding plurality of parallel parser threads running within one or more computing devices. A fragment order is assigned to the plurality of fragments. During a first processing phase of the parser threads, for each of one or more selected fragments of the plurality of fragments, a first available delimiter is determined within data content of the selected fragment. The data content within the selected fragment is parsed, starting from the first available delimiter to a last available delimiter within the fragment. During a second processing phase, for each of the one or more selected fragments, data content in a fragment suffix for the selected fragment is parsed with data content from a fragment prefix from a subsequent fragment.

Abstract: Provided are systems and methods for a first process for writing messages to a shared memory (each of the messages being written to a respective buffer of the shared memory, and the messages configured to be read in a specified sequence by a second process), determining that writing of one of the messages to the shared memory has been completed and, sending, to the second process and in response to determining that writing of one of the messages to the shared memory has been completed, an offset value corresponding to a location in the shared memory, wherein the second process is configured to read one or more messages that are stored in the portion of the shared memory before the offset value. Also the second process reads one or more messages stored in buffers that reside in the portion of the shared memory before the offset value, and commits the reads.