Abstract: Disclosed is a system, method, and computer program product for implementing a log analytics method and system that can configure, collect, and analyze log records in an efficient manner. Machine learning-based classification can be performed to classify logs. This approach is used to group logs automatically using a machine learning infrastructure.

Abstract: NUMA-aware reader-writer locks may leverage lock cohorting techniques that introduce a synthetic level into the lock hierarchy (e.g., one whose nodes do not correspond to the system topology). The synthetic level may include a global reader lock and a global writer lock. A writer thread may acquire a node-level writer lock, then the global writer lock, and then the top-level lock, after which it may access a critical section protected by the lock. The writer may release the lock (if an upper bound on consecutive writers has been met), or may pass the lock to another writer (on the same node or a different node, according to a fairness policy). A reader may acquire the global reader lock (whether or not node-level reader locks are present), and then the top-level lock. However, readers may only hold these locks long enough to increment reader counts associated with them.

Abstract: A “hybrid derived cache” stores semi-structured data or unstructured text data in an in-memory mirrored form and columns in another form, such as column-major format. The hybrid derived cache may cache scalar type columns in column-major format. The structure of the in-memory mirrored form of semi-structured data or unstructured text data enables and/or enhances access to perform path-based and/or text based query operations. A hybrid derived cache improves cache containment for executing query operations. The in-memory mirrored form is used to compute queries in a transactionally consistent manner through the use of an invalid vector that used to determine when to retrieve the transactionally consistent persistent form of semi-structured data or unstructured text data in lieu of the in-memory form.

Abstract: In accordance with an embodiment, described herein is a system and method for use with a multidimensional database computing environment. Particularly, a system and method are described for performing in-place data writes to a data storage medium associated with the multidimensional database computing environment. For example, when multiple data updates from calculation scripts are associated with a same set of blocks, the in-place data enable the system to reduce fragmentation of the data storage medium, and also to reduce contention due to index updates.

Abstract: A method for adapting data for changes in attributes associated with the data (e.g., data related to an enterprise) may include techniques for modifying attributes associated with data corresponding to a change in those attributes based on a change in a product (e.g., an application, a computer system, a computer program product, or a service). The data adaptation techniques may include determine attributes that have changed based on adaptation information that indicates changes in attributes associated with data accessed by the product. The adaptation may indicate conditions for those changes, such as a condition that indicates a change to an attribute corresponding to a change from one version of a product to another version of the product. Upon determining that a condition for a change to an attribute has occurred, the attribute may be modified based on the change.

Abstract: A method of providing Application Programming Interface (API) functions for registered service endpoints in container environments may include receiving, at an API registry, a request from a second service to use a first service in a container environment, where the API registry may list one or more API functions that call the first service. The method may also include generating, by the API registry, a client library for the second service that includes the one or more API functions to execute calls from the second service to the first service in the container environment.

Abstract: The present disclosure relates to a system and techniques for preventing corruption of snapshot data by limiting the visibility of committed data. To do this, the system may maintain an index that indicates the highest transaction identifier value such that no future commits will have a transaction identifier less than or equal to the indexed transaction identifier value. In embodiments, if a read is performed, only transactions having a transaction identifier less than or equal to the index value can be read. Each time that a transaction is committed, the index value is updated to the transaction identifier for the transaction having the highest transaction identifier without any intermediary transactions.

Abstract: A method for enabling 5G transport quality of service (QoS) includes receiving a service discovery request from a consumer network function (NF) or service communications proxy (SCP). The method further includes accessing a 5G transport QoS policy database and determining that a 5G transport QoS policy applies to the service discovery request. The method further includes, in response to determining that a 5G transport QoS policy applies to the discovery request, generating a service discovery response message and inserting a network layer QoS value for implementing the policy in the service discovery response message. The method further includes transmitting the service discovery response message to the consumer NF or SCP.

Abstract: Generic Concurrency Restriction (GCR) may divide a set of threads waiting to acquire a lock into two sets: an active set currently able to contend for the lock, and a passive set waiting for an opportunity to join the active set and contend for the lock. The number of threads in the active set may be limited to a predefined maximum or even a single thread. Generic Concurrency Restriction may be implemented as a wrapper around an existing lock implementation. Generic Concurrency Restriction may, in some embodiments, be unfair (e.g., to some threads) over the short term, but may improve the overall throughput of the underlying multithreaded application via passivation of a portion of the waiting threads.

Abstract: Systems, methods, and other embodiments associated with computing and generating schedule data structures for items in a display are described. In one embodiment, a method includes accessing a sales data structure corresponding to a store and analyzing sales records for items associated with subcategories to calculate a subcategory profit contribution score for each subcategory. The method may also include selecting a first subcategory from the subcategories as a candidate subcategory of items and analyzing the sales records to calculate an item profit contribution score for each of the items assigned to the candidate subcategory. A first item is selected from the candidate subcategory to be placed on a promotional display space, based upon the item profit contribution score of the first item. A schedule data structure is generated that assigns the first item to the promotional display space.

Abstract: Herein are techniques for dynamic aggregation of results of a database request, including concurrent grouping of result items in memory based on quasi-dense keys. Each of many computational threads concurrently performs as follows. A hash code is calculated that represents a particular natural grouping key (NGK) for an aggregate result of a database request. Based on the hash code, the thread detects that a set of distinct NGKs that are already stored in the aggregate result does not contain the particular NGK. A distinct dense grouping key for the particular NGK is statefully generated. The dense grouping key is bound to the particular NGK. Based on said binding, the particular NGK is added to the set of distinct NGKs in the aggregate result.

Abstract: Techniques for generating a report recommendation are disclosed. A system receives a request to display a report. The system computes report relevancy scores for other reports, based at least in part on a set of rules including one or more report relevancy criteria. Each report relevancy score measures relevancy of a particular report to the requested report. The system determines that a particular report relevancy score, associated with one of the other reports, satisfies one or more report recommendation criteria. Responsive to the request to display the requested report, the system displays the requested report and, based on the particular report relevancy score satisfying the one or more report recommendation criteria, also displays a recommendation corresponding to the other report.

Abstract: Techniques are described herein for a vectorized hash table that uses very efficient grow and insert techniques. A single-probe hash table is grown via vectorized instructions that split each bucket, of the hash table, into a respective upper and lower bucket of the expanded hash table. Further, vacant slots are indicated using a vacant-slot-indicator value, e.g., ‘0’, and all vacant slots follow to the right of all occupied slots in a bucket. A vectorized compare instruction determines whether a value is already in the bucket. If not, the vectorized compare instruction is also used to determine whether the bucket has a vacant slot based on whether the bucket contains the vacant-slot-indicator value. To insert the value into the bucket, vectorized instructions are used to shift the values in the bucket to the right by one slot and to insert the new value into the left-most slot.

Abstract: Systems and methods for supporting consistent path records across multiple subnets in a high performance computing environment. In accordance with an embodiment, a local inter-subnet manager (ISM) can determine one or more limitations associated with a calculated local path record. The local ISM can, upon receiving information regarding path limitations from a connected subnet, determine which limitations should be applied to inter-subnet traffic.

Abstract: Techniques for capturing query execution statistics are disclosed. The disclosed system determines which queries are executing during a sampling interval. The system identifies related queries that share similarity criteria with the currently executing query. The system obtains query execution statistics for the query executing during the sampling interval and any related queries. The system generates or obtains statistics during a monitoring window that spans a longer period of time than a single intervening period between the current sampling interval and a prior interval. The statistics are stored in permanent storage or transmitted to a requesting computer. The system refrains from analyzing statistics for queries (and any related queries) that did not execute during a current sampling interval.

Abstract: Generating persistent multifaceted statistical distributions of event data associated with computing nodes is disclosed. From a data stream, events are identified that occur during a first time interval. Characteristics associated with the events are determined. Based on a primary characteristic, it is determined that an event corresponds to an event cluster. The event count for that cluster is incremented. It is determined that the characteristics correspond to an event descriptor of events in the cluster. Responsive to requests to view the event cluster, information about descriptors from the cluster are displayed indicating events having a particular event descriptor, or a summary of characteristics that distinguish the descriptor from other event descriptors.

Abstract: A cloud manager restores a backup of a distributed environment by comparing a stack of a current distributed environment to a backup stack of the backup of the distributed environment. The cloud manager identifies a difference between a first number of nodes in the first set of nodes specified in the first stack and a second number of nodes in the second set of nodes specified in the second stack. The cloud manager restores the backup of the distributed environment by modifying a number of nodes in the current distributed environment based on the identified difference between the first number of nodes and the number of nodes in the second stack.

Abstract: Techniques for generating plug-in application recipe (PIAR) extensions are disclosed. A PIAR management application discovers a particular data type within one or more data values for a particular field of a plug-in application, where the particular data type is (a) different from a data type of the particular field as reported by the plug-in application and (b) narrower than the data type of the particular field while complying with the data type of the particular field. The PIAR management application identifies one or more mappings between (a) the particular data type and (b) one or more data types for fields accepted by actions of plug-in applications. The PIAR management application presents a user interface including one or more candidate PIAR extensions based on the mapping(s). Based on a user selection of a candidate PAIR extension, the PIAR management application executes a PIAR that includes the selected PIAR extension.

Abstract: A method for managing a current revision on prior revision of an order is described. A modified set of compensations tasks for addressing amendments indicated in the current revision are determined. The modified set of compensation tasks may be determined by carrying over one or more compensation tasks, associated with the prior revision, that have not yet been completed. Alternatively or additionally, the modified set of compensation tasks may be determined by adding new compensation tasks based on the current revision.

Abstract: Techniques for generating a composite score for data quality are disclosed. Univariate analysis is performed on a plurality of data points corresponding to each of a first feature, a second feature, and a third feature of a data set. The univariate analysis includes at least a first type of analysis generating a first score having a first range of possible values, and a second type of analysis generating a second score having a second range of possible values. A first quality score is computed for the data values for the first, second, and third features based on a normalized first score and a normalized second score. Machine learning is performed on the data points corresponding to one or both of the first feature and the second feature having a first quality score above a threshold value to model the third feature.

Abstract: Techniques for managing network-accessible infrastructure metadata are provided. A method includes receiving a resource request comprising resource metadata corresponding to a network-accessible infrastructure resource, determining whether to commit the resource request based at least in part on a constraint associated with the network-accessible infrastructure resource, and, in accordance with a determination to commit the resource request: generating, by the computer system, a resource identifier describing resource metadata in accordance with the resource request, storing, by the computer system, the resource metadata in a data store in communication with the computer system, receiving, by the computer system, a data request to provide the resource metadata described by the resource identifier, and providing, by the computer system, the resource metadata described by the resource identifier in accordance with the data request.

Abstract: Embodiments include methods and systems for configuring a dashboard with a plurality of components. Data sets populated by a plurality of data attributes and associated data attribute values can be received, where the dashboard is configured to display data from the data sets. A plurality of components can be provided on the dashboard including a guided discovery component that displays suggested filters for the dashboard according to one or more of the received data sets. A selection of a filter for the dashboard can be received at one of the components and the components can be dynamically filtered based on the received filter. The suggested filters displayed by the guided discovery component can also be dynamically adjusted based on the received filter, where one or more suggested filters are dynamically hidden and one or more suggested filters are dynamically displayed based on the received filter.

Abstract: Systems and methods for path record handling in a fabric without host stack cooperation in a high performance computing environment. In a case where the subnet manager has determined “homogenous subnet/fabric” or “semi-homogenous subnet/fabric” status for the current topology, but is still receiving path queries, the subnet manager can use the relevant status to avoid any route evaluation and generate path record either only based on the configuration status of the requesting port in the homogenous case, or by comparing the configuration status of both ports in the semi-homogenous case.

Abstract: Techniques for processing a natural language query are provided. The techniques include obtaining a set of statistics representing a contextual significance of a set of words in a data model for a data set. Next, the set of statistics is used to match a set of semantic intents for a natural language query of the data set to one or more data elements in the data model. The data element(s) and the data set are then to generate a result of the natural language query, and the result is provided in a response to the natural language query.

Abstract: Embodiments determine anomalies in sensor data generated by a plurality of sensors that correspond to a single asset. Embodiments receive a first time window of clean sensor input data generated by the sensors, the clean sensor data including anomaly free data comprised of clean data points. Embodiments divide the clean data points into training data points and evaluation data points, and divide the training data points into a pre-defined number of plurality of segments of equal length. Embodiments convert each of the plurality of segments into corresponding segment curves using Kernel Density Estimation (“KDE”) and determine a Jensen-Shannon (“JS”) divergence value for each of the plurality of segments using the segment curves to generate a plurality of JS divergence values. Embodiments then assign the maximum value of the plurality of JS divergence values as a threshold value and validate the threshold value using the evaluation data points.

Abstract: A system includes a transmitting agent configured to select a transport mechanism for transmitting a data item, and a receiving agent configured to select one or more data repositories and a storage process for storing the data item. One storage process includes storing the data item temporarily in the second data repository, and subsequently transferring the data item from the second data repository into the first data repository. Another storage process includes storing the data item into a first data repository without temporarily storing the data item in the second data repository.

Abstract: Techniques for visualizing data elements are disclosed. A system presents a first data element profile comprising: a first data element; a second data element; and a first formula used to calculate a value of the first data element using a value of the second data element. The system detects user input selecting the second data element. Based on detecting the user input, the system presents a second data element profile comprising: the second data element; a third data element; and a second formula used to calculate a value of the second data element using a value of the third data element. The system detects user input selecting the third data element. Based on detecting the user input, the system presents a third data element profile comprising the third data element.

Abstract: Computer code is received that is written using a dynamic Domain Specific Language (DSL) running in a General Purpose Language (GPL) computing environment. A compiler performs static compiler analysis on the computer code. The static compiler analysis includes referencing a security policy defining one or more unacceptable program behaviors. During compile time at the compiler, runtime security checking functionality is performed leveraging compiler extensions, type information, and environment specific compile context. Results of the static compiler analysis are used to indicate when execution of the computer code would result in performance of the one or more unacceptable program behaviors. The one or more unacceptable program behaviors include modifying preexisting computer code to incorporate the computer code written using the DSL.

Abstract: A computer comprising one or more processors and memory may implement an atomic compare and swap (CAS) operation on multiple data elements. Each data element has a corresponding descriptor which includes a new value and a reference to a controlling descriptor for the CAS operation. The controlling descriptor includes a status value which indicates whether the CAS operation is in progress or has completed. The operation first allocates memory locations of the data elements by writing addresses of respective descriptors to the memory locations using CAS instructions. The operation then writes successful status to the status value of the controlling descriptor to indicate that the respective memory locations are no longer allocated. The operation then returns an indicator of successful completion without atomically updating the memory locations with the new values. Extensions are further described to implement CAS operations in non-volatile random access memories.

Abstract: In the described examples a given graphical user interface (GUI) instance of a set of GUI instances for a given transaction with an external system is provided. The given GUI instance of the given transaction comprises a set of data fields for completing the given transaction. The set of data fields exposed in the given GUI instance are dependent on execution of an operation in another GUI instance in the set of GUI instances for the given transaction, wherein the given GUI instance of the transaction receives a given data set for the set of data fields. The given data set characterizes user input for the given GUI instance of the given transaction, and the given data set and the given GUI instance of the given transaction correspond to a given state of the given transaction. A transaction state logger tracks the given transaction.

Abstract: Techniques are provided herein for contextual embedding of features of operational logs or network traffic for anomaly detection based on sequence prediction. In an embodiment, a computer has a predictive recurrent neural network (RNN) that detects an anomalous network flow. In an embodiment, an RNN contextually transcodes sparse feature vectors that represent log messages into dense feature vectors that may be predictive or used to generate predictive vectors. In an embodiment, graph embedding improves feature embedding of log traces. In an embodiment, a computer detects and feature-encodes independent traces from related log messages. These techniques may detect malicious activity by anomaly analysis of context-aware feature embeddings of network packet flows, log messages, and/or log traces.

Abstract: Techniques for brokering authorization between a user-facing service and a backend service are disclosed. A proxy service, operating independently of the user-facing service and the backend service, exposes an application programming interface (API) configured to receive requests from the user-facing services to perform functions of the plurality of backend services. The proxy service stores user authorization data that authorizes a user of a particular user-facing service to use a function of a backend service. The proxy service receives, via the API, a request to perform the function for an account associated with the user. Responsive to receiving to the request, the proxy service uses the user authorization data to access the backend service to perform the function for the account associated with the user.

Abstract: The fail-over computer cluster enables multiple computing devices to operate using adaptive quorum rules to dictate which nodes are in the fail-over cluster at any given time. The adaptive quorum rules provide requirements for communications between nodes and connections with voting file systems. The adaptive quorum rules include particular recovery rules for unplanned changes in node configuration, such as due to a disruptive event. Such recovery quorum rules enable the fail-over cluster to continuing to operate with various changed configurations of its node members as a result of the disruptive event. In the changed configuration, access to voting file systems may not be required for a majority-group subset of nodes. If no majority-group subset remains, nodes may need direct or indirect access to voting file systems.

Abstract: Techniques for self-service provisioning and activation of cloud services are disclosed. In some embodiments, a self-service user interface is generated through which a cloud service subscriber may input configuration parameters to customize an instance of the cloud service. The configuration parameters may define topology, deployment, and/or operational configurations for the cloud service. Responsive to receiving configuration parameters through the self-service user interface, a set of instructions may be automatically generated and executed to perform one or more provisioning operations.

Abstract: The present disclosure provides a detailed description of techniques used in methods, systems, and computer program products for associating anonymous information to personally identifiable information without sharing any personally identifiable information. A method receives a specification record comprising one or more specified demographic attributes to be used in user record selection operations, the results of which operations include user records that comprise a user identifier and at least some non-personally-identifiable information. A candidate group is formed by applying a set of rules over the retrieved user records to reject-out one or more user records that comprise mutually-exclusive characteristics with respect to the other user records in the candidate group. An anonymity measure is calculated over the candidate group to satisfy a threshold of anonymity. If needed to satisfy the threshold of anonymity, additional user records are added to the group before any sharing operations.

Abstract: Techniques are described for enabling resources within a cloud computing system to interact with each other. In certain embodiments, a base identifier assigned to a first resource is extended by mapping the base identifier onto a second identifier assigned to a logical resource that is built upon the first resource. This allows the first resource to have two identities, one identity indicating what the first resource is (e.g., a particular compute instance) and another identity indicating the purpose of the first resource (e.g., operating as a database for a particular tenancy). Consequently, the first resource may be provided with access privileges different from those associated with the base identifier. For example, the first resource may access another resource in the tenancy using the second identifier, but may have no access to the other resource using the base identifier.

Abstract: Techniques for identifying anomalous multi-source data points and ranking the contributions of measurement sources of the multi-source data points are disclosed. A system obtains a data point including a plurality of measurements from a plurality of sources. The system determines that the data point is an anomalous data point based on a deviation of the data point from a plurality of additional data points. The system determines a contribution of two or more measurements, from the plurality of measurements, to the deviation of the data point from the plurality of additional data points. The system ranks the at least the two or more measurements, from the plurality of measurements, based on the respective contribution of each of the two or more measurements to the deviation of the anomalous data point from the plurality of prior data points.

Abstract: The disclosed embodiments provide a system that detects unwanted electronic components in a target asset. During operation, the system obtains target electromagnetic interference (EMI) signals by monitoring EMI signals generated by the target asset while the target asset is running a periodic workload. Next, the system generates a target EMI fingerprint from the target EMI signals. The system then applies a compression/dilation technique to time-series signals in the target EMI fingerprint to achieve alignment with corresponding time-series signals in a reference EMI fingerprint to produce a synchronized target EMI fingerprint. Finally, the system compares the synchronized target EMI fingerprint against the reference EMI fingerprint to determine whether the target asset contains any unwanted electronic components.

Abstract: Described is an improved approach to implement an offline learning approach for machine learning that employs a window-based technique for predicting values within the window, and where outliers are identified and discarded from consideration. This approach efficiently permits offline learning to be employed in a manner that minimizes false positives, while also improving the quality of the data should retaining be required.

Abstract: Techniques are described for enabling resources within a cloud computing system to interact with each other. In certain embodiments, a resource is assigned a digital token that provides certain access privileges for the duration in which the digital token is valid. The digital token permits the resource to have access for a duration sufficient to perform some operation (e.g., run one-time code or the same code periodically on a scheduled basis), but without extending the level of access for significantly longer than necessary to complete the operation. Each time the resource principal is to perform the operation, the token can be reissued to the resource to provide the resource with time-limited access privileges. The use of this short-lived token avoids having to create permanent credentials for the resource.

Abstract: Techniques are described for enabling resources within a cloud computing system to interact with each other. In certain embodiments, a token renewal mechanism is provided for extending the duration in which a first resource can access another resource. The token renewal mechanism can involve the first resource periodically causing a new credential to be generated for itself and then communicating the new credential to an identity and access management (IAM) system. The new credential may be generated for compliance with a credential rotation policy specifying that credentials should be changed after a certain period of time. The IAM system may associate a digital access token with the new credential so that for subsequent requests, the IAM system will only recognize the resource principal based upon the new credential. The digital token can be invalidated if a new credential is not changed within the specified period of time.

Abstract: Example embodiments facilitate extending client-side software functionality to leverage server-side functionality, such as server-side business logic implementing custom actions and accessible to a specialized add-in to the client-side software, e.g., a client-side spreadsheet. An example method includes exposing one or more parameters of server-side logic in a client-side spreadsheet, wherein the server-side logic includes code for implementing one or more software actions; providing input to one or more spreadsheet fields corresponding to the one or more parameters, there by allocating one or more values to the one or more parameters; detecting user selection of a User Interface (UI) control for using the server-side logic to implement the one or more software actions; and sending the one or more values to the server-side logic via one or more web services, thereby providing the one or more values as input to the server-side logic.

Abstract: The fail-over computer cluster enables multiple computing devices to operate using adaptive quorum rules to dictate which nodes are in the fail-over cluster at any given time. The adaptive quorum rules provide requirements for communications between nodes and connections with voting file systems. The adaptive quorum rules include particular recovery rules for unplanned changes in node configuration, such as due to a disruptive event. Such recovery quorum rules enable the fail-over cluster to continuing to operate with various changed configurations of its node members as a result of the disruptive event. In the changed configuration, access to voting file systems may not be required for a majority-group subset of nodes. If no majority-group subset remains, nodes may need direct or indirect access to voting file systems.

Abstract: Techniques for self-service provisioning and activation of cloud services are disclosed. In some embodiments, a self-service user interface is generated through which a cloud service subscriber may input configuration parameters to customize an instance of the cloud service. The configuration parameters may define topology, deployment, and/or operational configurations for the cloud service. Responsive to receiving configuration parameters through the self-service user interface, a set of instructions may be automatically generated and executed to perform one or more provisioning operations.

Abstract: Techniques are provided for performing a flush operation in a non-coherent cache. In response to determining to perform a flush operation, a cache unit flushes certain data items. The flush operation may be performed in response to a lapse of a particular amount of time, such as a number of cycles, or an explicit flush instruction that does not indicate any cache entry or data item. The cache unit may store change data that indicates which entry stores a data item that has been modified but not yet been flushed. The change data may be used to identify the entries that need to be flushed. In one technique, a dirty cache entry that is associated with one or more relatively recent changes is not flushed during a flush operation.

Abstract: A method may include generating, by performing a full analysis of code and for each component of the code, summaries including: (i) a forward summary including a forward flow and (ii) a backward summary including a backward flow, obtaining a modification to a modified component, determining that one of the summaries for the modified component is invalid, and in response to determining that a summary for the modified component is invalid: obtaining the forward flow from the forward summary of the modified component, obtaining the backward flow from the backward summary of the modified component, generating a local flow by performing an incremental analysis of the modified component using the forward flow of the modified component and the backward flow of the modified component, and detecting a defect in the code using the forward flow of the modified component, the local flow, and the backward flow of the modified component.

Abstract: A method may include receiving a continuous query identified by an archived relation associated with an application. The method may also include generating a physical query plan. Additionally, the method may include constructing a structured query language (SQL) equivalent expression corresponding to an attribute utilized by the operator and/or constructing an output SQL expression for the identified operator based at least in part on the SQL equivalent expression. Additionally, the method may include constructing the archiver query for the identified operator based at least in part on the output SQL expression. Further, the method may include executing the archiver query to obtain a result set of data records related to the application and/or generating a snapshot output of one or more data values related to the application based at least in part on the result set of data records.

Abstract: The disclosed embodiments provide a system that detects unwanted electronic components in a target asset. During operation, the system obtains target electromagnetic interference (EMI) signals by monitoring EMI signals generated by the target asset while the target asset is running a periodic workload. Next, the system generates a target EMI fingerprint from the target EMI signals. The system then applies a compression/dilation technique to time-series signals in the target EMI fingerprint to achieve alignment with corresponding time-series signals in a reference EMI fingerprint to produce a synchronized target EMI fingerprint. Finally, the system compares the synchronized target EMI fingerprint against the reference EMI fingerprint to determine whether the target asset contains any unwanted electronic components.

Abstract: A programming language framework may be enhanced to provide for dynamic validation. Dynamic validation allows the validator function for any variable to be selected at runtime rather than statically declared at programming-time. Instead of annotating a variable with an annotation that refers to a specific validator function or constraint type, programmers can annotate a variable with an annotation that indicates that the validator function will be selected dynamically at runtime. When a runtime instance of the variable is created, the programming language framework may identify the dynamic validation annotation on the variable, and then use the runtime values in the variable to determine which validator function(s) should be used.

Abstract: Techniques for efficient continuation stack storage are disclosed. In some embodiments, when a continuation yields, the continuation stack, or portion thereof, is copied from a thread stack to a data object, referred to herein as a chunk, allocated from memory. The copied stack portion may maintain the same representation in the chunk as on the thread stack to minimize processing overhead of the operation. When the continuation resumes, the continuation stack, or some portion thereof, is copied from the chunk to the thread stack. During execution, the continuation stack that was copied may be modified on the thread stack. When the continuation yields again, the runtime environment may determine, based at least in part on whether the first object in memory is subject to a garbage collection barrier, whether to copy the modified portion of the continuation stack to the existing chunk or to allocate a new chunk.