Shared Compilation Cache Verification System

Abstract

In an example aspect, example embodiments of the present disclosure provide an example computer-implemented method for validating a shared cache. The example method can include retrieving a pre-compiled shared cache entry corresponding to a shared cache key associated with an operation request. The example method can include obtaining a directly-compiled resource associated with the operation request. The example method can include authenticating one or more portions of the shared cache based at least in part on a comparison of the pre-compiled shared cache entry and the directly-compiled resource.

Description

Technical Field

[0001] The present disclosure generally relates to data caching. More specifically, the present disclosure relates to verifying entries in a shared cache. Background Art

[0002] A computing node may operate in a just-in-time compilation mode, in which code for performing a requested operation may be compiled on demand. However, to avoid repeated compilation, a cache of pre-compiled binaries may be made available to the computing node such that when the operation is requested a second time or at a subsequent time, the code may be retrieved from the cache and executed on the computing node. Summary of the Invention

[0003] Aspects and advantages of embodiments of the present disclosure will be set forth in part in the following description, or may be learned from the description, or may be learned through practice of the embodiments.

[0004] In one aspect, the present disclosure provides an example computer-implemented method for authenticating a shared cache. The example method includes a computing system including one or more processors retrieving a pre-compiled shared cache entry corresponding to a shared cache key associated with an operation request. The example method includes the computing system obtaining a directly-compiled resource associated with the operation request. The example method includes the computing system authenticating one or more portions of the shared cache at least in part based on a comparison of the pre-compiled shared cache entry and the directly-compiled resource.

[0005] In another aspect, the present disclosure provides an example non-transitory computer-readable medium storing instructions that, when executed, cause one or more processors to perform example operations. The example operations include retrieving a pre-compiled shared cache entry corresponding to a shared cache key associated with an operation request. The example operations include obtaining a directly-compiled resource associated with the operation request. The example operations include authenticating one or more portions of the shared cache at least in part based on a comparison of the pre-compiled shared cache entry and the directly-compiled resource.

[0006] In another aspect, the present disclosure provides an example shared cache verification system. The example system includes one or more processors. The example system includes one or more non-transitory computer-readable media that include instructions that, when executed, cause the one or more processors to perform example operations. The example operations include receiving, from a computing node that processes a requested operation, a request for a pre-compiled shared cache entry from a shared cache. The example operations include obtaining an authentication status of the shared cache based at least in part on a comparison of (i) directly compiled resources compiled by the computing node for performing the requested operation and (ii) the pre-compiled shared cache entry, wherein the authentication status indicates that the pre-compiled shared cache entry is incompatible with the computing node. The example operations include deactivating the shared cache for one or more future requests from the computing node.

[0007] Other aspects of the present disclosure relate to various systems, devices, non-transitory computer-readable media, user interfaces, and electronic devices.

[0008] These and other features, aspects, and advantages of the various embodiments of the present disclosure will be better understood with reference to the following description and the appended claims. The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate example embodiments of the present disclosure and, together with the description, serve to explain the relevant principles. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] A detailed discussion of embodiments directed to those of ordinary skill in the art is set forth in this specification with reference to the accompanying drawings.

[0010] Figure 1A A block diagram depicting an example computing system that performs shared compilation cache verification in accordance with an example embodiment of the present disclosure.

[0011] Figure 1B A block diagram depicting an example computing device that performs shared compilation cache verification in accordance with an example embodiment of the present disclosure.

[0012] Figure 1C A block diagram depicting an example computing device that performs shared compilation cache verification in accordance with an example embodiment of the present disclosure.

[0013] Figure 2 A block diagram depicting additional aspects of an example shared compilation cache verification system in accordance with an example embodiment of the present disclosure.

[0014] Figure 3 A block diagram depicting an example data flow for aspects of an example shared compilation cache verification system in accordance with an example embodiment of the present disclosure.

[0015] Figure 4A block diagram depicting an example state - based pattern for an example shared compilation cache verification system in accordance with an example embodiment of the present disclosure.

[0016] Figure 5 A block diagram depicting an example data flow for an example shared compilation cache verification system that utilizes an unauthenticated cache in accordance with an example embodiment of the present disclosure.

[0017] Figure 6 A block diagram depicting an example data flow for an example shared compilation cache verification system that utilizes an authenticated cache in accordance with an example embodiment of the present disclosure.

[0018] Figure 7 A block diagram depicting an example data flow for an example shared compilation cache verification system that utilizes an invalid cache in accordance with an example embodiment of the present disclosure.

[0019] Figure 8 A flowchart depicting an example method for performing shared cache verification in accordance with an example embodiment of the present disclosure.

[0020] Figure 9 A flowchart depicting another example method for performing shared cache verification in accordance with an example embodiment of the present disclosure.

[0021] Reference numerals that are repeated across multiple figures are intended to identify the same features in various implementations. Detailed Description

[0022] Overview

[0023] Generally, the present disclosure relates to systems and methods for shared cache verification. For example, example embodiments according to aspects of the present disclosure relate to techniques for managing a shared cache of compiled resources. For example, in some embodiments, when multiple computing nodes are configured to be available for performing the same or similar operations, a shared cache can be made available to the nodes such that resources that have been compiled by one node can be reused by another node to perform the same or similar operations. However, in some scenarios, deploying a shared cache can be associated with risks of incompatibility. For example, a shared cache entry compiled on one node may not be fully compatible with another node or may otherwise be unable to execute on another node (e.g., due to hardware differences, firmware differences, software differences, configuration differences, etc.). Resource incompatibility can be associated with risks such as system failures, data loss, downtime, vulnerabilities, etc.

[0024] Advantageously, systems and methods according to example aspects of the present disclosure can provide improved verification of a shared cache. For example, in some embodiments, the shared cache can be authenticated according to aspects of the present disclosure before the shared cache is trusted to provide cache resources between multiple endpoints. For example, in some embodiments, an authentication state (e.g., the state includes valid / authenticated, invalid, unauthenticated, etc.) can be assigned to the shared cache. The authentication state can be maintained, updated, and / or reset according to a state-based approach.

[0025] In some embodiments, the authentication state can be determined by verifying one or more pre-compiled shared cache entries in the shared cache against one or more resources directly compiled for a desired endpoint (e.g., locally compiled, compiled by a just-in-time compiler, etc.). For example, directly compiled counterparts compiled for or by a node can be referenced as examples of resources compatible with that node. In this way, for example, the pre-compiled shared cache entries can be verified to be compatible by comparing them with known compatible resources.

[0026] For example, in some embodiments, a computing node can receive a request to perform an operation. The computing node can query the shared cache to obtain pre-compiled resources associated with the requested operation. In some cases, the computing node can also obtain directly compiled resources for the requested operation (e.g., locally compiled by the node, compiled by a just-in-time compiler for the node, etc.) and compare the results with the pre-compiled resources retrieved from the shared cache. In some embodiments, based on the comparison (e.g., a positive comparison, such as a match), the pre-compiled resources can be verified (e.g., indicating that they are compatible). In this way, for example, it can be determined that the pre-compiled resources in the shared cache are compatible, thereby leveraging the pre-compiled resources to obtain improved performance across one or more computing nodes. However, in some embodiments, based on obtaining a negative comparison (e.g., detecting an incompatibility, etc.), the shared cache can be deactivated in whole or in part to avoid or reduce the risk of executing incompatible resources on one or more connected computing nodes.

[0027] In some embodiments according to example aspects of the present disclosure, pre-compiled cache entries can be stored in the shared cache in association with a shared cache key. The shared cache key can be configured as a handle to retrieve the corresponding pre-compiled cache entry. For example, in some examples, a pre-compiled shared cache resource can be initialized and assigned a shared cache key that encodes one or more identifiers of the resource. In some embodiments, the identifier can link a request (e.g., a request processed by a computing node) to the resource for performing the requested operation on the computing node.

[0028] For example, in some embodiments, a shared cache key can be configured to distinguish a target shared cache entry for performing a requested operation on a compute node from other entries (e.g., other resources that are incompatible with the compute node). In some embodiments, the shared cache key can include an abbreviated representation of the shared cache entry or a pointer to the shared cache entry. In some embodiments, for example, the abbreviated representation of the shared cache entry can include a hash or other encoding of one or more aspects or portions of the shared cache entry (e.g., a hash or other encoding of the entry's tag, marker, header, structure, content, locator, etc.). In some embodiments, the abbreviated representation of the shared cache entry can include a hash or other encoding of one or more aspects or portions of a request for an operation to be performed by the shared cache entry. For example, in some embodiments, a shared cache key can be generated from a request for an operation on a compute node, and the key can match a previously stored key associated with a pre-compiled shared cache entry previously compiled on the same or a similar (e.g., cross-compatible) compute node. In this way, for example, given a request for an operation (e.g., a function call, etc.), a shared cache key can be obtained that is operable to retrieve from the shared cache a resource configured to perform the requested operation. And in this way, for example, the shared cache key can be configured to retrieve compatible entries in the shared cache.

[0029] To help ensure that the shared cache key appropriately retrieves compatible shared cache entries (e.g., configured to adequately distinguish cross-node incompatibilities), systems and methods according to example aspects of the present disclosure can provide shared cache authentication. The shared cache can be associated with, for example, an authentication status indicator or other authentication determined based on a checksum of one or more entries in the shared cache.

[0030] For example, a retrieved shared cache entry for performing an operation associated with a request can be compared to a directly compiled resource associated with the request. In some embodiments, the directly compiled resource can include a resource locally compiled by the node requesting the cached resource. In some embodiments, the directly compiled resource can be compiled by a just-in-time compiler (e.g., on the node, on a server serving the node, etc.). In some examples, for example, the directly compiled resource can be compiled by a compiler configured to compile resources compatible with the target node.

[0031] In some embodiments, the directly compiled resource can include, for example, executable code that is compiled to perform an operation associated with the request. The shared cache entry can include, for example, pre-compiled executable code that is also configured to perform an operation associated with the request.

[0032] The comparison of directly compiled resources with shared cache entries can include, for example, a comparison of fingerprints (e.g., a provided identifying hash or other encoding) for each of the directly compiled resources and the shared cache entries. For example, in some embodiments, if one or more portions of each of the directly compiled resources and the shared cache entries correspond to equivalent (e.g., identical) hash values, it can be determined that the shared cache entry can be fully interchanged with the directly compiled resource such that the shared cache entry can be trusted to execute compatibly on the computing node. In this way, for example, one or more shared cache entries (e.g., and / or the keys associated therewith) can be verified by a successful comparison with one or more corresponding directly compiled resources (e.g., a comparison that meets one or more compatibility criteria, etc.).

[0033] In some embodiments, the fingerprints used in verifying one or more shared cache entries can be configured to reveal differences between the one or more shared cache entries and their directly compiled counterparts. For example, in some embodiments, the fingerprints can be configured to reflect the content of the resources (e.g., shared cache entries, directly compiled resources, etc.) in a granular manner. For example, the fingerprints can include hash values or other encodings generated from the resources (e.g., for the entire content of the resource, for the operational content of the resource, etc.). In this way, for example, the fingerprints can advantageously reveal potential incompatibilities between the directly compiled resources and the shared cache entries, even if the shared cache entries are retrieved by a shared cache key associated with both the directly compiled resources and the shared cache entries.

[0034] In some embodiments, for example, fingerprints can be used as a verification of the reliability of the shared cache key configuration. For example, in a simple example, consider a request to perform operation A on a computing node. The key can be some encoding of "operation A", and the computing node can use the key to query the shared cache to retrieve a pre-compiled shared cache entry labeled with the key indicating "operation A". To test whether the pre-compiled shared cache entry is compatible with the computing node, the computing node can obtain the directly compiled resource for performing the requested operation A. The directly compiled resource can be compared with the retrieved pre-compiled shared cache entry for verification. However, the comparison (e.g., of hash values, other encodings, etc.) can reveal that the retrieved resource is different from the directly compiled resource and is thus an invalid resource for the requesting node. For example, the retrieved pre-compiled resource may have been compiled by a node of type 1 to perform operation A, while the requesting node belongs to type 2, which is incompatible with resources compiled by nodes of type 1. Since the shared cache key configuration pattern cannot distinguish resources compiled for type 1 nodes from resources compiled for type 2 nodes, one or more portions of the shared cache can be de-authenticated or otherwise invalidated to prevent the provision of invalid cache resources.

[0035] Example embodiments in accordance with example aspects of the present disclosure provide a variety of technical effects and benefits. By providing improved verification of a shared cache implementation, example embodiments can provide improved performance of a computing system by leveraging pre-compiled code across one or more individual nodes, such that the individual nodes do not needlessly perform duplicate compilations. For example, example embodiments can provide increased speed, reduced latency, reduced network bandwidth requirements, reduced power consumption, reduced memory usage, etc. for one or more computing nodes (e.g., individually and / or jointly) by providing a secure and reliable method for deploying a shared cache system. For example, when a new computing node comes online, traditionally it may lack a pre-populated local cache, such that operations performed on the new node may not generally benefit from processing improvements of cache resources and thus all operations must be compiled on demand - however, according to example embodiments of the present disclosure, an authenticated shared cache can be used to more efficiently populate the local cache of the new node, thereby advantageously reducing the processing requirements (e.g., and associated lead times) for bringing the new node online. In another example, for instance, an existing node may encounter a new task, and example embodiments of the shared cache system according to the present disclosure can provide pre-compiled resources to the node to process the new task at improved speed and efficiency without the need to directly compile the resources to complete the task.

[0036] In certain example embodiments, another additional advantage includes improved robustness against execution failures and / or other consequences of incompatible or unapproved code. For example, in some examples, improved verification techniques in accordance with aspects of the present disclosure can improve the system reliability and / or security of one or more computing nodes, thereby providing increased uptime, fewer unauthorized execution events, fewer maintenance costs (e.g., computational costs for debugging, labor time and expense costs, etc.). In this way, for example, less computing resources can be consumed to provide a target level of uptime, reliability, and / or security. Alternatively or additionally, in some embodiments, increased uptime, reliability, and / or security can be achieved by more efficiently using computing resources (e.g., reduced network bandwidth requirements, reduced power consumption, reduced memory usage, etc.). In this way, for example, the operation of example embodiments of the computing system itself can be improved by reducing the risk of failure while providing improved processing, latency, etc.

[0037] Reference will now be made to the accompanying drawings to discuss example embodiments of the present disclosure in more detail.

[0038] Example Apparatus and System

[0039] Figure 1AFIG. 0 is a block diagram depicting an example computing system 100 that performs shared cache verification in accordance with an example embodiment of the present disclosure. The system 100 includes a computing device 102, a server computing system 130, and a training computing system 150 communicatively coupled via a network 180.

[0040] The computing device 102 can be any type of computing device, such as, for example, a personal computing device (e.g., a laptop computer or a desktop computer), a mobile computing device (e.g., a smartphone or a tablet computer), a gaming console or controller, a wearable computing device, an embedded computing device, a workstation, a computing endpoint of a distributed system, a server computing device, a host device for one or more virtual machines, or any other type of computing device.

[0041] The computing device 102 includes one or more processors 112 and a memory 114. The one or more processors 112 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, an FPGA, a controller, a microcontroller, etc.) and can be a single processor or multiple processors operatively connected. The memory 114 can include one or more non-transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, disks, etc., and combinations thereof. The memory 114 can store data 116 and instructions 118 that are executed by the processor 112 to cause the computing device 102 to perform operations.

[0042] The memory 114 can further include a local cache 120 that is used to store compiled instructions (e.g., compiled instructions 118) for execution on the computing device 102. For example, a local compiler 122 can compile the instructions 118 (e.g., for performing one or more operations of a machine learning model 124). To provide reduced processing requirements and reduced latency for one or more future executions of the instructions 118, one or more compiled instructions can be stored in the local cache 120.

[0043] In some implementations, the computing device 102 can store or include one or more machine learning models 124. For example, the machine learning model 124 can be or can otherwise include various machine learning models, such as neural networks (e.g., deep neural networks) or other types of machine learning models, including non-linear models and / or linear models. Neural networks can include feedforward neural networks, recurrent neural networks (e.g., long short-term memory recurrent neural networks), convolutional neural networks, or other forms of neural networks. Some example machine learning models can utilize an attention mechanism, such as self-attention. For example, some example machine learning models can include a multi-head self-attention model (e.g., a transformer model).

[0044] In some implementations, one or more machine learning models 124 can be received via network 180 from server computing system 130, stored in computing device memory 114, and then used or otherwise implemented by one or more processors 112. In some implementations, computing device 102 can implement multiple parallel instances of a single machine learning model 124.

[0045] Additionally or alternatively, one or more machine learning models 144 can be included in or otherwise stored and implemented by server computing system 130, which communicates with computing device 102 according to a client-server relationship. For example, machine learning model 144 can be implemented by server computing system 140 as part of a web service. Thus, one or more models 124 can be stored and implemented at computing device 102, and / or one or more models 144 can be stored and implemented at server computing system 130.

[0046] Server computing system 130 includes one or more processors 132 and memory 134. One or more processors 132 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, an FPGA, a controller, a microcontroller, etc.) and can be a single processor or multiple processors operatively connected. Memory 134 can include one or more non-transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, disks, etc., and combinations thereof. Memory 134 can store data 136 and instructions 138 that are executed by processor 132 to cause server computing system 130 to perform operations.

[0047] The memory 134 may also include a shared cache 140 that stores compiled instructions (e.g., compiled instructions 118, compiled instructions 138) for execution on the computing device 102, the server computing system 130, and / or the training computing system 150. For example, the server compiler 142 may compile the instructions 118 and / or the instructions 138 (e.g., for performing one or more operations of the machine learning model 124 and / or the machine learning model 144). To provide reduced processing requirements and reduced latency for one or more future executions of the instructions 118 and / or the instructions 138, one or more compiled instructions may be stored in the shared cache 140. In some embodiments, as discussed herein, the shared cache 140 may be configured to provide one or more entries (e.g., resources, such as pre-compiled resources) to one or more other systems and devices via the network 180. In some embodiments, multiple computing devices 102 each communicate with the server computing system 130 and are configured to receive pre-compiled resources from the shared cache 140. For example, in some embodiments, the system 100 may coordinate compilation tasks among the computing device 102, the training computing system 150, and the server computing system 130 to utilize the shared cache 140 (and in some embodiments, the more powerful processor 132 and / or the compiler 142).

[0048] In some implementations, the server computing system 130 includes or is otherwise implemented by one or more server computing devices. In cases where the server computing system 130 includes multiple server computing devices, such server computing devices may operate according to a sequential computing architecture, a parallel computing architecture, or some combination thereof.

[0049] As described above, the server computing system 130 may store or otherwise include one or more machine learning models 144. For example, the model 144 may be or may otherwise include various machine learning models. Example machine learning models include neural networks or other multi-layer non-linear models. Example neural networks include feed-forward neural networks, deep neural networks, recurrent neural networks, and convolutional neural networks. Some example machine learning models may utilize an attention mechanism, such as self-attention. For example, some example machine learning models may include a multi-head self-attention model (e.g., a transformer model).

[0050] The computing device 102 and / or the server computing system 130 may train the model 124 and / or 144 via interaction with the training computing system 150 communicatively coupled via the network 180. The training computing system 150 may be separate from the server computing system 130 or may be a part of the server computing system 130.

[0051] The training computing system 150 includes one or more processors 152 and a memory 154. The one or more processors 152 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, an FPGA, a controller, a microcontroller, etc.) and can be a single processor or multiple processors operatively connected. The memory 154 can include one or more non-transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, disks, etc., and combinations thereof. The memory 154 can store data 156 and instructions 158 that are executed by the processor 152 to cause the training computing system 150 to perform operations. In some implementations, the training computing system 150 includes one or more server computing devices, or is otherwise implemented by one or more server computing devices.

[0052] The memory 154 may further include a local cache 160 that is used to store compiled instructions (e.g., the compiled instructions 158) for execution on the training computing system 150. For example, a local compiler 162 can compile the instructions 158 (e.g., for performing one or more operations of the model trainer 164). To provide reduced processing requirements and reduced latency for one or more future executions of the instructions 158, one or more of the compiled instructions can be stored in the local cache 160.

[0053] The training computing system 150 can include a model trainer 164 that trains a machine learning model 124 and / or 144 stored at the computing device 102 and / or the server computing system 130 using various training or learning techniques (e.g., such as error backpropagation). For example, a loss function can be backpropagated through the model to update one or more parameters of the model (e.g., based on the gradient of the loss function). Various loss functions can be used, such as mean squared error, likelihood loss, cross-entropy loss, hinge loss, and / or various other loss functions. Gradient descent techniques can be used to iteratively update the parameters over multiple training iterations.

[0054] In some implementations, performing error backpropagation can include performing truncated backpropagation through time. The model trainer 164 can perform various generalization techniques (e.g., weight decay, dropout, etc.) to improve the generalization ability of the model being trained. Specifically, the model trainer 164 can train the machine learning model 124 and / or 144 based on a set of training data.

[0055] In some implementations, if consent is provided, training examples may be provided by computing device 102. Thus, in such implementations, the model 124 provided to computing device 102 may be trained by training computing system 150 based on device-specific data received from computing device 102. In some cases, this process may be referred to as personalizing the model.

[0056] Model trainer 164 includes computer logic for providing the desired functionality. Model trainer 164 may be implemented in hardware, firmware, and / or software that controls a general-purpose processor. For example, in some implementations, model trainer 164 includes program files stored on a storage device, loaded into memory, and executed by one or more processors. In other implementations, model trainer 164 includes a set of one or more computer-executable instructions stored in a tangible computer-readable storage medium (such as RAM, a hard disk, or optical or magnetic media).

[0057] Network 180 can be any type of communication network, such as a local area network (e.g., an intranet), a wide area network (e.g., the Internet), or some combination thereof, and can include any number of wired or wireless links. Generally, communication over network 180 can be performed using a variety of communication protocols (e.g., TCP / IP, HTTP, SMTP, FTP), encodings or formats (e.g., HTML, XML), and / or protection modes (e.g., VPN, secure HTTP, SSL) via any type of wired and / or wireless connection.

[0058] Figure 1A An example computing system 100 that can be used to implement the present disclosure is shown. Other computing systems can also be used. For example, in some implementations, computing device 102 may include model trainer 164 and a training data set. In such implementations, model 124 can be both locally trained and used at computing device 102. In some of such implementations, computing device 102 may implement model trainer 164 to personalize model 124 based on device-specific data.

[0059] Figure 1B A block diagram of an example computing device 10 performing according to an example embodiment of the present disclosure is depicted. In various embodiments, computing device 10 can be a client computing device or a server computing device. For example, computing device 10 may correspond to computing device 102. In some embodiments, computing device 10 (e.g., computing device 102) may provide machine learning model operations to one or more client computing devices via network 180.

[0060] Computing device 10 includes multiple applications (e.g., Application 1 to Application N). Each application contains its own machine learning library and machine learning model. For example, each application may include a machine learning model. Example applications include a text messaging application, an email application, a dictation application, a virtual keyboard application, a browser application, and the like.

[0061] As Figure 1B shown, each application may communicate with multiple other components of the computing device (e.g., such as one or more sensors, a context manager, a device status component, and / or additional components). In some implementations, each application may use an API (e.g., a common API) to communicate with each device component. In some implementations, the API used by each application is specific to the application.

[0062] Figure 1C A block diagram of an example computing device 50 executing in accordance with an example embodiment of the present disclosure is depicted. Computing device 50 may be a client computing device or a server computing device.

[0063] Computing device 50 includes multiple applications (e.g., Application 1 to Application N). Each application communicates with a central intelligence layer. Example applications include a text messaging application, an email application, a dictation application, a virtual keyboard application, a browser application, and the like. In some implementations, each application may use an API (e.g., a common API across all applications) to communicate with the central intelligence layer (and the models stored therein).

[0064] The central intelligence layer includes multiple machine learning models. For example, as Figure 1C shown, a corresponding machine learning model may be provided for each application, and the corresponding machine learning model may be managed by the central intelligence layer. In other implementations, two or more applications may share a single machine learning model. For example, in some implementations, the central intelligence layer may provide a single model for all applications. In some implementations, the central intelligence layer is included within or otherwise implemented by the operating system of computing device 50.

[0065] The central intelligence layer may communicate with a central device data layer. The central device data layer may be a centralized data repository of computing device 50. As Figure 1C shown, the central device data layer may communicate with multiple other components of the computing device (e.g., such as one or more sensors, a context manager, a device status component, and / or additional components). In some implementations, the central device data layer may use an API (e.g., a private API) to communicate with each device component.

[0066] Figure 2Shows multiple computing devices 102-1, 102-2,......, 102-n served by a shared cache 210. As shown, the computing devices 102-1, 102-2,......, 102-n respectively include one or more processors 112-1, 112-2,......, 112-n and memories 114-1, 114-2,......, 114-n. The one or more processors can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, an FPGA, a controller, a microcontroller, etc.) and can be one processor or multiple processors operatively connected. The memory can include one or more non-transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, disks, etc. and combinations thereof. The memories 114-1, 114-2,......, 114-n can respectively store data 116-1, 116-2,......, 116-n and instructions 118-1, 118-2,......, 118-n executed by the processors to cause the corresponding computing devices to perform operations.

[0067] The memories 114-1, 114-2,......, 114-n can also respectively include local caches 120-1, 120-2,......, 120-n for storing compiled instructions respectively compiled by local compilers 122-1, 122-2,......, 122-n for execution on the corresponding computing devices. To provide reduced processing requirements and reduced latency for one or more future executions of the instructions, one or more compiled instructions can be stored in the local caches of the corresponding computing devices.

[0068] However, in some embodiments, one or more of the computing devices 102-1, 102-2, ..., 102-n may be requested to perform a task for which the corresponding local cache does not contain pre-compiled resources. For example, computing device 102-n may be initialized and added to an array of computing devices, and its local cache 120-n may not yet contain any pre-compiled resources. In one example, the local cache 120-1 of computing device 102-1 may store pre-compiled resources in the shared cache 210 as a pre-compiled shared cache entry 212 associated with a shared cache key 220. For example, computing device 102-1 may cause the pre-compiled shared cache entry 212 (e.g., resources compiled by compiler 122-1) to be stored and cause it to be associated with the shared cache key 220 (e.g., a key configured to enable retrieval of the pre-compiled shared cache entry 212). Thus, in some embodiments, computing device 102-n may receive a request to perform an operation associated with the shared cache key 220. Accordingly, computing device 102-n may query the shared cache 210 using the shared cache key 220 to retrieve the pre-compiled shared cache entry 212 for performing the requested operation. If the shared cache 210 has a valid certificate 214 (e.g., a certificate indicating that the shared cache 210 is compatible with computing device 102-n), then computing device 102-n may use the pre-compiled shared cache entry 212 to perform the requested operation. Similarly, in some embodiments, if the shared cache 210 has a positive certificate 214, one or more entries of the shared cache 210 may be (e.g., automatically, before receiving an associated request, etc.) populated into the cache 120-n of computing device 102-n.

[0069] Figure 3 An example state-based method for determining an authentication status (e.g., for updating certificate 214) is shown. The initialization state 300 of the shared cache may be marked as "unauthenticated". This state may be updated during a verification update cycle 310 and / or an authentication update cycle 320. The verification update cycle 310 includes determining the verification status of one or more entries of the shared cache (e.g., the pre-compiled shared cache entry 212 of the shared cache 210) and / or the shared cache key associated therewith at a verification check 312. A verification failure triggers an invalid state update 314.

[0070] Figure 4The block diagram therein illustrates an example method for performing a verification check 312. A source 410 (e.g., selected or otherwise determined based on a request to perform an operation, etc.) can be provided to each of two processing streams. In one aspect, the source 410 can be provided to a local compiler 420 (e.g., provided to local compiler 122, such as provided to local compiler 122 from memory 114, etc.). The compiler 420 can output a directly compiled resource 430 (e.g., a compiled source 410), and the directly compiled resource can be processed to obtain a fingerprint 440 that identifies the content of the compiled resource 430. In another aspect, a shared cache key 450 can be associated with the source 410 (e.g., generated based on a request for the source 410 such as a request to perform an operation performed by the source 410, etc.), and the shared cache key 450 can be used to query a shared cache (e.g., shared cache 210) to obtain a shared cache hit 460. The shared cache hit 460 can indicate that a pre-compiled resource 470 has been retrieved from the shared cache based on the shared cache key 450 (e.g., the shared cache key 450 is a handle for retrieving the pre-compiled resource 470). A fingerprint 480 can be obtained based on the pre-compiled resource 470, and the fingerprint identifies the content of the pre-compiled resource 470.

[0071] In some embodiments, the fingerprints 440, 480 can be processed at a comparison 490 to determine whether the pre-compiled resource 470 is equivalent (e.g., interchangeable, compatible, identical, etc.) to the compiled resource 430. For example, in some embodiments, the fingerprints 440, 480 can be configured to represent or otherwise identify (e.g., uniquely identify) the content of the corresponding resources (e.g., the compiled resource 430, the pre-compiled resource 470, etc.) at a granularity sufficient to capture differences between the resources that could result in incompatibility. For example, in some embodiments, the fingerprints 440, 480 can include hash values or other encodings of the content (e.g., a portion, some, or all, etc.) of the corresponding resources.

[0072] In some embodiments, the output of the comparison 490 can include an indication of the validity of the pre-compiled resource 470. For example, a determination of "valid" can be based on functional equivalence or interoperability with the compiled resource 430. In some embodiments, a match (e.g., an identical match, etc.) between the fingerprints 440 and 480 can indicate the validity of the pre-compiled resource 470.

[0073] Refer again to Figure 3, in some embodiments, if the cache entry is valid, the state of the shared cache is maintained (e.g., in an unauthenticated state). During the authentication period 320, the shared cache is evaluated at the eligibility check 322 to determine whether the shared cache has been sufficiently verified. For example, in some embodiments, one verified entry may qualify the shared cache. However, in some embodiments, the eligibility threshold may require verifying multiple shared cache entries before setting the shared cache state to authenticated at 324.

[0074] In some embodiments, once authenticated, the shared cache may be re - authenticated periodically. For example, in some embodiments, after being authenticated, the shared cache may periodically (e.g., for selected queries to the cache) re - check verification at 312, and a verification failure causes the shared cache state to be set to invalid. In some embodiments, the shared cache state may be periodically reset to unauthenticated. For example, the shared cache state may be reset to unauthenticated to trigger re - eligibility of the cache at 322 via verification of one or more (e.g., multiple) shared cache entries at 312. In this way, for example, in some embodiments, the certificate of the shared cache (e.g., certificate 214) can be maintained.

[0075] In some embodiments, the certificate of the shared cache can be updated based on one or more trigger events. For example, the shared cache certificate can be updated (e.g., reset, re - checked, etc.) after a set time period, a set number of cache hits, exceeding a hit rate threshold, etc. In some embodiments, the shared cache certificate can be updated when a node newly served by the shared cache queries the cache. For example, one or more entries of the shared cache can be verified (e.g., verified according to the present disclosure, such as by techniques Figure 4 discussed, etc.) relative to the newly served node, such that the shared cache can be qualified as authenticated relative to the newly served node and trusted to provide shared cache entries to that node. In some embodiments, for example, the shared cache can contain multiple entries: a subset can be used to authenticate (or re - authenticate) the shared cache, and a portion or all of the remainder can be provided to the receiving node (e.g., to fill the node's local cache, etc.).

[0076] In some embodiments, if the cache entry verification fails at the verification check 312, the state of the shared cache can be set to invalid (e.g., at 314). For example, an invalid state or certificate can cause one or more portions of the shared cache to be deactivated. For example, in some embodiments, the invalidated shared cache stops providing entries to one or more nodes (e.g., all nodes). In some embodiments, the shared cache can revert to the last known authenticated state: for example, the shared cache can discard newly added entries and / or stop serving new nodes for which the cached entry verification fails (e.g., a secure operating mode can be provided until further debugging). In some embodiments, the invalid state update can trigger an update to the shared cache key configuration. For example, if the shared cache key retrieves an incompatible resource from the shared cache (e.g., resulting in a verification failure), then in some embodiments, it can be determined that the shared cache key fails to identify the cached resource with sufficient specificity to capture and respond to cross-node incompatibilities, and the shared cache key configuration pattern can be updated to, for example, include a more detailed identifier (e.g., increase the bit depth of the key encoding, change the generation of the key encoding to capture additional or different information, or otherwise be modified to reduce conflicts, etc.).

[0077] Figure 5 Illustrates an example extension of the state-based approach when the shared cache is in an unauthenticated state Figure 3 of the state-based approach. Although Figure 5The decision boxes in are depicted in the drawn arrangements, but it should be understood that additional and alternative arrangements are envisioned and are within the scope of the present disclosure. In some embodiments, at 502, a request can be made for an operation to be performed. In some embodiments, for example, a request can be made to a computing node to cause the computing node to perform an operation (e.g., by invoking a function of the computing node, such as a machine learning function or operation, etc.). Based on the request 502, it can be determined that resources are needed to perform the requested operation. In some embodiments, the resource is a computer code resource. In some embodiments, the resource needs to be compiled for execution or otherwise benefits from being compiled for execution. At 504, a local cache can be queried to determine whether the required resource has been previously compiled and is available for local execution. A local cache hit (e.g., indicating a matching entry corresponding to the query) can provide, at 506, using the local cache entry to service the request 502, and for the current cycle or iteration, the data flow can end at 599. A local cache miss (e.g., indicating a failure to find an entry corresponding to the query) can provide, at 508, compiling the required resource (e.g., locally, on a server, etc.) for the computing node, and using the compiled resource at 510 since the shared cache is in an uncertified state. At 512, a shared cache can be queried for an entry corresponding to the required resource (e.g., using a shared cache key). If the query misses, the shared cache can be populated at 514 with the resource compiled at 508. If the query hits and an entry is retrieved from the cache, the retrieved resource can be verified at 516 (e.g., by comparing the compiled resource with the resource retrieved from the cache). If invalid, the authentication status or certificate of the shared cache can be updated at 518 from uncertified (UNCERTIFIED) to invalid (INVALID). If the retrieved resource is valid (e.g., matches, is compatible, interoperable, etc. with the compiled resource), it can be determined at 520 whether the cache has been sufficiently verified to meet the authentication qualification. If it does not meet the qualification, the cycle or iteration ends, optionally while incrementing at 516 a verification count or other indicator of verification. If the cache does meet the qualification (e.g., based on a qualification metric, such as a threshold number of valid entries retrieved, etc.), the authentication status can be updated at 522 from uncertified to certified (CERTIFIED).

[0078] Figure 6 Shows an example extension of the state-based method when the shared cache is in a certified state Figure 3 Although Figure 6The decision boxes in [description] are depicted in the drawn arrangement, but it should be understood that additional and alternative arrangements are envisioned and are within the scope of the present disclosure. In some embodiments, a request for an operation can be obtained at 602. Based on the request 602, a local cache can be queried at 604 for an entry corresponding to the resources required to perform the requested operation. If the query returns a hit, the retrieved local cache entry can be used at 606 to perform the requested operation, and the current cycle can end at 699. If the local cache query misses, an authenticated shared cache can be queried at 608. If the shared cache also misses, the required resources can be compiled and used at 610 (e.g., locally, at a server, etc.). However, if the shared cache query returns a hit (e.g., a shared cache entry is retrieved using the shared cache key as a handle), the retrieved shared cache entry can be used at 612.

[0079] Figure 7 illustrates an example extension of the state-based approach when the shared cache is in an invalid state Figure 3 Although Figure 7 The decision boxes in [description] are depicted in the drawn arrangement, but it should be understood that additional and alternative arrangements are envisioned and are within the scope of the present disclosure. In some embodiments, a request for an operation can be obtained at 702. Based on the request 702, a local cache can be queried at 704 for an entry corresponding to the resources required to perform the requested operation. If the query returns a hit, the retrieved local cache entry can be used at 706 to perform the requested operation, and the current cycle can end at 799. If the local cache query misses, the required resources can be compiled and used at 708 (e.g., locally, at a server, etc.).

[0080] Example Method

[0081] Figure 8 Depicts a flowchart of an example method 800 for execution in accordance with an example embodiment of the present disclosure. Although Figure 8 For purposes of illustration and discussion, the steps are depicted as being performed in a particular order, but the methods of the present disclosure are not limited to the specifically illustrated order or arrangement. Without departing from the scope of the present disclosure, the various steps of method 800 can be omitted, rearranged in various ways, combined, and / or adapted.

[0082] In some example aspects, example method 800 provides, in some embodiments, a computer-implemented method for authenticating a shared cache. For example, a computing node or device (such as a computing system) may receive a request to perform an operation. For example, the request may include substantially any processing task, such as a function call, a queued task, a distributed process, etc. Performing the operation may use, execute, or otherwise implement one or more resources. In some embodiments, a resource may be compiled to perform the operation (e.g., requires compilation to run, better performance at compile time, etc.) - in some embodiments, for example, performing the requested operation may include executing compiled computer code.

[0083] In some embodiments, a compiled resource is desired to perform the operation. In some embodiments, a cache of previously used or obtained resources may improve the speed of performing the operation using the cached resources (e.g., by providing a faster retrieval than recompiling the resource). However, in some embodiments, example method 800 includes determining by the computing system that there is no locally cached pre-compiled resource associated with the operation request. For example, a computing node or device may query a first cache (e.g., a local cache) to obtain a cached copy of the pre-compiled resource. However, in certain cases, the first cache (e.g., the local cache) does not contain the requested resource.

[0084] At 802, example method 800 may include retrieving a pre-compiled shared cache entry corresponding to a shared cache key. In some embodiments, the shared cache key may be associated with the operation request. For example, the operation request may indicate the operation to be performed and may be associated with a shared cache key for retrieving one or more resources for performing the operation. For example, in some embodiments, the shared cache key may be generated at least in part based on the operation request and configured to identify one or more resources.

[0085] At 804, example method 800 may include obtaining a directly compiled resource associated with the operation request (e.g., from a just-in-time compiler). For example, in some embodiments, the computing system may both retrieve the pre-compiled shared cache entry and generate or otherwise obtain a directly compiled resource corresponding to the pre-compiled shared cache entry.

[0086] At 806, example method 800 may include authenticating one or more portions of the shared cache based at least in part on a comparison of the pre-compiled shared cache entry and the directly compiled resource (e.g., as described above with respect to Figures 3 to 7As described above. In some embodiments, for example, the comparison includes comparing the fingerprint (e.g., hash, etc.) of the directly compiled resource with the fingerprint of the precompiled shared cache entry. In some embodiments, the precompiled shared cache entry is compiled for or by a computing system that is the same as or equivalent to the computing system of the directly compiled resource, such that the precompiled shared cache entry and the directly compiled resource are effectively equivalent (e.g., interoperable, interchangeable, etc.) and / or the same.

[0087] For example, a failure of the comparison to indicate a match may indicate that the precompiled shared cache entry is not a valid equivalent of the directly compiled resource and is thus retrieved ineffectively via the shared cache key. For example, the example method 800 may include deactivating one or more portions of the shared cache by the computing system at least in part based on determining that the precompiled shared cache entry is invalid.

[0088] For example, a comparison indicating a match may indicate that the precompiled shared cache entry is valid and is retrieved effectively via the shared cache key. In this way, for example, it can be determined that the shared cache reliably provides compatible cache resources and can be used to provide precompiled resources for performing the requested operations. In some embodiments, a qualification threshold may be used to determine the number of entries verified before certifying one or more portions of the shared cache as a whole. For example, the example method 800 may include updating, by the computing system, a plurality of comparisons indicating the validity of one or more shared cache entries of the shared cache, the plurality of comparisons corresponding to the qualification threshold, and determining, by the computing system, to certify the shared cache at least in part based on the plurality of comparisons meeting the qualification threshold.

[0089] In some embodiments, the example method 800 may include maintaining, by the computing system, the certification status of one or more portions of the shared cache. For example, in some embodiments (e.g., as described above with respect to Figures 3 to 7 As described above), the certificate of the shared cache (e.g., or one or more portions thereof) may indicate a certification status such as uncertified, certified, invalid, etc. The example method 800 may include updating, for example, the certification status by the computing system at least in part based on the comparison. In some embodiments, the example method 800 includes periodically resetting, by the computing system, the certification status of the shared cache. For example, it may be desirable to re-certify one or more portions of the shared cache periodically (e.g., for reliability, security, maintenance, etc.).

[0090] Figure 9 Depicts a flowchart of an example method 900 for execution in accordance with an example embodiment of the present disclosure. Although Figure 9For purposes of illustration and discussion, steps are depicted in a particular order, but the methods of the present disclosure are not limited to the specifically recited order or arrangement. The various steps of method 900 may be omitted, rearranged in various ways, combined, and / or adapted without departing from the scope of the present disclosure.

[0091] At 902, example method 900 may include receiving, from a computing node processing a requested operation, a request for a pre-compiled shared cache entry from a shared cache. In some embodiments, a shared cache key is used to retrieve the shared cache entry for the computing node.

[0092] At 904, example method 900 may include obtaining an authentication status of the shared cache (e.g., as described above with respect to Figures 3 to 7 ), where the authentication status indicates incompatibility of the pre-compiled shared cache entry, at least in part based on a comparison of (i) directly-compiled resources (e.g., compiled for, by, etc., the computing node by a just-in-time compiler, etc.) for performing the requested operation and (ii) the pre-compiled shared cache entry. In some embodiments, the comparison may include a comparison of a fingerprint of the directly-compiled resources with a fingerprint of the pre-compiled shared cache entry.

[0093] At 906, example method 900 may include deactivating the shared cache for one or more future requests from the computing node. For example, the shared cache may be taken completely offline. For example, if the shared cache key retrieves a shared cache entry that is incompatible with the query node, the shared cache may be taken offline (e.g., stop providing cache entries) to prevent further provision of incompatible entries in the shared cache key mode. For example, in some embodiments, a check failure may indicate that the shared cache key mode cannot accurately identify compatible resources for the requesting computing system / device and cannot distinguish incompatible resources. In some embodiments, the shared cache may be reset to the last known safe configuration (e.g., state since the previous check, etc.), and / or one or more previously checked and authenticated portions of the shared cache may be maintained while one or more other portions may stop serving.

[0094] Additional Disclosure

[0095] The techniques discussed herein relate to servers, databases, software applications, and other computer-based systems, as well as the actions taken and the information sent to and from such systems. The inherent flexibility of computer-based systems allows for many possible configurations, combinations, and divisions of tasks and functions among components. For example, the processes discussed herein may be implemented using a single device or component or multiple devices or components working in combination. Databases and applications may be implemented on a single system or distributed across multiple systems. Distributed components may operate sequentially or in parallel.

[0096] Although the present subject matter has been described in detail with respect to various specific example embodiments of the subject matter, each example is provided by way of explanation and not as a limitation of the disclosure. After understanding the foregoing, those skilled in the art can readily generate such changes, alterations, and equivalents of such embodiments. Accordingly, the disclosure does not exclude including such modifications, alterations, and / or additions to the subject matter that would be readily understood by one of ordinary skill in the art. For example, features shown or described as part of one embodiment can be used with another embodiment to yield yet another embodiment. Accordingly, the disclosure is intended to cover such changes, alterations, and equivalents.

Claims

1. A computer-implemented method for authenticating a shared cache, comprising: Retrieve, by a computing system including one or more processors, a precompiled shared cache entry corresponding to a shared cache key associated with an operation request; Obtain, by the computing system, a directly compiled resource associated with the operation request; And Authenticate, by the computing system, one or more portions of the shared cache based at least in part on a comparison of the precompiled shared cache entry and the directly compiled resource.

2. The computer-implemented method according to claim 1, further comprising: Determine, by the computing system, that there is no precompiled resource in a local cache associated with the operation request.

3. The computer-implemented method according to claim 1, wherein obtaining, by the computing system, the directly compiled resources associated with the operation request comprises: Obtain, by the computing system, the directly compiled resource from a just-in-time compiler.

4. The computer-implemented method according to claim 1, wherein the comparison comprises comparing the fingerprint of the directly compiled resources with the fingerprint of the pre-compiled shared cache entry.

5. The computer-implemented method according to claim 1, wherein authenticating, by the computing system, one or more portions of the shared cache based at least in part on the comparison comprises: Update, by the computing system, a plurality of comparisons indicating the validity of one or more shared cache entries of the shared cache, the plurality of comparisons corresponding to an eligibility threshold.

6. The computer-implemented method according to claim 5, further comprising: Determine, by the computing system, to authenticate the shared cache based at least in part on the plurality of comparisons meeting the eligibility threshold.

7. The computer-implemented method according to claim 1, wherein authenticating, by the computing system, one or more portions of the shared cache based at least in part on the comparison comprises: Deactivate, by the computing system, one or more portions of the shared cache based at least in part on determining that the precompiled shared cache entry is invalid.

8. The computer-implemented method according to claim 1, further comprising: Maintain, by the computing system, an authentication status of one or more portions of the shared cache; And Update, by the computing system, the authentication status based at least in part on the comparison.

9. The computer-implemented method according to claim 8, further comprising: Periodically reset, by the computing system, the authentication status of the shared cache.

10. A non-transitory computer-readable medium storing instructions that, when executed, cause one or more processors to perform operations, the operations comprising: Retrieve a precompiled shared cache entry corresponding to a shared cache key associated with an operation request; Obtain a directly compiled resource associated with the operation request; And Authenticate at least in part one or more portions of the shared cache based on a comparison of the precompiled shared cache entry and the directly compiled resource.

11. The computer-readable medium according to claim 10, wherein the operations further comprise: Determine that there is no precompiled resource in a local cache associated with the operation request.

12. The computer-readable medium according to claim 10, wherein obtaining the directly-compiled resource associated with the operation request comprises: Obtain the directly compiled resource from a just-in-time compiler.

13. The computer-readable medium according to claim 10, wherein the comparison comprises comparing a fingerprint of the directly-compiled resource with a fingerprint of the pre-compiled shared cache entry.

14. The computer-readable medium according to claim 10, wherein authenticating the shared cache based at least in part on the comparison comprises: Update a plurality of comparisons indicating the validity of one or more shared cache entries of the shared cache, the plurality of comparisons corresponding to an eligibility threshold.

15. The computer-readable medium according to claim 14, wherein the operation further comprises: Determine to authenticate the shared cache based at least in part on the plurality of comparisons meeting the eligibility threshold.

16. The computer-readable medium according to claim 10, wherein authenticating the shared cache based at least in part on the comparison comprises: Deactivate at least in part one or more portions of the shared cache based on determining that the precompiled shared cache entry is invalid.

17. The computer-readable medium according to claim 10, wherein the operation further comprises: Maintain an authentication status of one or more portions of the shared cache; And Update the authentication status based at least in part on the comparison.

18. A shared cache verification system, comprising: One or more processors; And One or more non-transitory computer-readable media including instructions that, when executed, cause the one or more processors to perform operations including: Receive, from a computing node that processes an operation of a request, a request for a precompiled shared cache entry from a shared cache; Obtain an authentication status of the shared cache based at least in part on a comparison of (i) a directly compiled resource for performing the requested operation on the computing node and (ii) the precompiled shared cache entry, wherein the authentication status indicates an incompatibility of the precompiled shared cache entry with the computing node; and Deactivate the shared cache for one or more future requests from the compute node, at least in part based on the authentication status.

19. The system according to claim 18, wherein the directly-compiled resource is compiled for the compute node.

20. The system according to claim 19, wherein the comparison comprises comparing a fingerprint of the directly-compiled resource with a fingerprint of the pre-compiled shared cache entry.

21. A computer-implemented method for obtaining a shared cache entry from a shared cache, comprising: obtaining, by a local computing system including one or more processors, an operation request; The local computing system determines that there is no precompiled resource in the local cache to satisfy the operation request; And The local computing system receives a precompiled shared cache entry corresponding to the shared cache key from the shared cache system, where the shared cache key is associated with the operation request; Wherein, the shared cache system is associated with an authentication status indicating that the precompiled shared cache entry is compatible with the local computing system, and the authentication status is determined by comparing the precompiled resources stored in the shared cache system with the just-in-time compiled resources.

22. The computer-implemented method according to claim 21, comprising: receiving, by a shared cache system, a query for pre-compiled resources for satisfying an operation request from a local computing system; The shared cache system retrieves the precompiled shared cache entry using the shared cache key associated with the query; The shared cache system determines the authentication status of the precompiled shared cache entry; And The shared cache system returns the precompiled shared cache entry to the local computing system.

23. The computer-implemented method according to claim 22, wherein, Determining the authentication status of the precompiled shared cache entry by the shared cache includes: The shared cache system obtains the directly compiled resources associated with the operation request; And The shared cache system authenticates one or more parts of the shared cache at least in part based on the comparison of the precompiled shared cache entry with the directly compiled resources.

24. The computer-implemented method according to claim 23, wherein, Obtaining the directly compiled resources includes: Compiling the resources with a just-in-time compiler.

25. The computer-implemented method according to claim 21, comprising: receiving, by a shared cache system, resources compiled by different local computing systems from different local computing systems; and storing, by the shared cache system, the resources as pre-compiled shared cache entries.

26. The computer-implemented method according to claim 25, comprising: generating, by the shared cache system, a shared cache key to enable retrieval of the pre-compiled shared cache entry.

27. The computer-implemented method according to claim 21, comprising: updating, by the shared cache system, an authentication status based on one or more trigger events.

28. The computer-implemented method according to claim 27, wherein, The one or more trigger events include at least one of the following: a set time period, a set number of cache hits, or a hit rate threshold.

29. The computer-implemented method according to claim 27, wherein, The one or more trigger events include a query from a new compute node.

30. A non-transitory computer-readable medium storing instructions that, when executed, cause one or more processors to perform operations, the operations comprising: obtaining, by a local computing system including one or more processors, an operation request; The local computing system determines that there is no precompiled resource in the local cache to satisfy the operation request; And The local computing system receives a precompiled shared cache entry corresponding to the shared cache key from the shared cache system, where the shared cache key is associated with the operation request; Wherein, the shared cache system is associated with an authentication status indicating that the precompiled shared cache entry is compatible with the local computing system, and the authentication status is determined by comparing the precompiled resources stored in the shared cache system with the just-in-time compiled resources.

31. The non - transitory computer - readable medium according to claim 30, wherein the operations include: receiving, by the shared cache system, from a local computing system, a query for pre - compiled resources for satisfying an operation request; The shared cache system retrieves the precompiled shared cache entry using the shared cache key associated with the query; The shared cache system determines the authentication status of the precompiled shared cache entry; And The shared cache system returns the precompiled shared cache entry to the local computing system.

32. The non - transitory computer - readable medium according to claim 31, wherein, Determining the authentication status of the precompiled shared cache entry by the shared cache includes: The shared cache system obtains the directly compiled resources associated with the operation request; And The shared cache system authenticates one or more parts of the shared cache at least in part based on the comparison of the precompiled shared cache entry with the directly compiled resources.

33. The non - transitory computer - readable medium according to claim 32, wherein, Obtaining the directly compiled resources includes: Compiling the resources with a just-in-time compiler.

34. The non - transitory computer - readable medium according to claim 30, wherein the operations include: receiving, by the shared cache system, resources compiled by different local computing systems from different local computing systems; and storing, by the shared cache system, the resources as pre - compiled shared cache entries.

35. The non - transitory computer - readable medium according to claim 30, wherein the operations include: generating, by the shared cache system, a shared cache key to enable retrieval of the pre - compiled shared cache entries.

36. The non - transitory computer - readable medium according to claim 30, wherein the operations include: updating, by the shared cache system, an authentication status based on one or more trigger events.

37. The non - transitory computer - readable medium according to claim 36, wherein, The one or more trigger events include at least one of the following: a set time period, a set number of cache hits, or a hit rate threshold.

38. The non - transitory computer - readable medium according to claim 36, wherein, The one or more trigger events include a query from a new compute node.

39. A computing system, comprising: a shared cache system, wherein, The shared cache system includes one or more non-transitory computer-readable media storing: Compiled resources for execution on one or more local computing systems; and Shared cache system instructions that, when executed by one or more processors of the shared cache system, cause the shared cache system to: Receive a query for a pre-compiled resource from a local computing system; Retrieve a pre-compiled shared cache entry using a shared cache key associated with the query; Determine an authentication status of the pre-compiled shared cache entry, where the authentication status indicates that the pre-compiled shared cache entry is compatible with the local computing system, and the authentication status is determined by comparing the pre-compiled resource stored by the shared cache system with a just-in-time compiled resource; and Return the pre-compiled shared cache entry; and The one or more local computing systems, where each respective local computing system includes one or more respective non-transitory computer-readable media storing: A respective local cache; and Local computing system instructions that, when executed by one or more processors of the respective local computing system, cause the respective local computing system to: Obtain an operation request; Determine that there is no pre-compiled resource in the respective local cache for satisfying the operation request; and Query the shared cache system to obtain a pre-compiled shared cache entry.

40. The computing system according to claim 39, wherein, When executed by one or more processors of the shared cache system, the shared cache system instructions cause the shared cache system to: store and verify the compiled resources received from the one or more local computing systems.

Images