Abstract: In accordance with an embodiment, described herein is a system and method for transaction recovery in a multitenant application server environment. At least one resource manager associated with a partition can be designated as a determiner resource for that partition only, in order to support eliminating transaction logs (TLOG) in processing a two-phase commit transaction. A transaction manager can prepare all other resource managers in the mid-tier transactional system before the determiner resource. Furthermore, the transaction manager can rely on the list of outstanding transactions to be committed that is provided by the determiner resource for recovering the transaction. The transaction manager can commit an in-doubt transaction returned from a resource manager that matches the list of in-doubt transactions returned from the determiner resource. Otherwise, the transaction manager can roll back the in-doubt transaction.

Abstract: The present disclosure relates to systems and methods that enhance multivariate testing of interface variants by intelligently allocating network traffic to increase the speed at which samples sizes reach statistical significance. More particularly, the present disclosure relates to systems and methods that intelligently select interface variants to test against a control interface in a manner that efficiently reduces the uncertainty of sample sizes (e.g., the variance of the sample mean), thereby reaching statistical significance quicker.

Abstract: A system may include a computer processor and a repository configured to store a first code fragment including language features represented in a first programming language, and a second code fragment including language features represented in a second programming language. The system may further include a universal code fragment classifier, executing on the computer processor and configured to generate a first universal abstract syntax tree for the first code fragment and a second universal abstract syntax tree for the second code fragment, generate, using a graph embedding model, first vectors for the first universal abstract syntax tree and second vectors for the second universal abstract syntax tree, and classify, by executing an abstract syntax tree classifier on the first vectors and the second vectors, the first code fragment as a first code category and the second code fragment as a second code category.

Abstract: A computer-implemented method interfaces with a remote attachment from a spreadsheet program on a client device. A first area in the spreadsheet associates with a top-level object in a web server, and a second area associates with a descendant object. On a first user interaction with a cell in the second area, a user interface item is shown, allowing uploading and/or downloading the attachment. When the user interacts to upload or download, the program uploads (or queues for upload) a selected attachment and modifies attachment metadata in the second area, or downloads the attachment based on attachment metadata in the second area. Communication between the spreadsheet program and the web server may be REST compliant.

Abstract: Techniques for a database management system to predict when in the future a materialized view will be used for query rewrite. This is a followed by an approach that uses the quiet rewrite pattern prediction to determine an optimized schedule for refreshing the materialized view. The approach combines the query rewrite pattern prediction with a quiet period prediction for the materialized view and an estimated refresh duration for the materialized view to determine the optimized refresh schedule for the materialized view.

Abstract: Systems, methods, and other embodiments associated with protecting online content are described. In one embodiment, a method includes generating a hashed code, and generating an encrypted and signed hash. The method may also include transmitting the encrypted and signed hash and the domain to a blockchain, causing: the blockchain to request validation the encrypted and signed hash by a terminal associated with a registrar of the domain; and the terminal associated with the registrar to: (a) decrypt the encrypted and signed hash using the private key to obtain the hashed code, (b) attempt to validate an authenticity of the hashed code, and (c) control inclusion of the hashed code in a blockchain record based on a result of the attempt to validate the authenticity of the hashed code.

Abstract: Techniques for executing operations associated with sub-sets of queries in a set of nested queries are disclosed. A graphical user interface displays individual sub-queries as separate visual representations. Based on detecting a selection, a system executes a selected query in the set of nested queries, without executing parent queries in the set of nested queries. Based on detecting another selection, the system exports a selected query without exporting parent queries of the selected query. The system copies the metadata describing the selected query and transfers the metadata to another set of nested queries. Based on detecting another selection, the system displays a results count for a selected query. The system displays a number representing the number of results returned by the selected query, without displaying the query results.

Abstract: Herein are resource-constrained techniques that plan ahead for resiliently moving pluggable databases between container databases after a failure in a high-availability database cluster. In an embodiment that has a database cluster that hierarchically contains many pluggable databases in many container databases in many virtual machines, a computer identifies many alternative placements that respectively assign each pluggable database instance (PDB) to a respective container database management system (CDBMS). For each alternative placement, a respective placement score is calculated based on the PDBs and the CDBMSs. Based on the placement scores of the alternative placements, a particular placement is selected with a best placement score that indicates optimal resilience for accommodating adversity such as failover and overcrowding.

Abstract: The present disclosure relates to chatbot systems, and more particularly, to techniques for obtaining data items for input to a chatbot. In certain embodiments, a chatbot system includes a component that can be invoked by a chatbot in the chatbot system to obtain data items needed by the chatbot. The component can be invoked based on a reference to the component in a dialog flow definition configured for the chatbot. The reference to the component can indicate a composite entity that the component will use to determine how the data items are obtained from a user. The composite entity acts as a container for the data items and may be configured separately from the dialog flow definition of the chatbot. The data items can be obtained based on rules specified in a composite entity definition configured for the composite entity.

Abstract: Techniques support graph pattern matching queries inside a relational database management system (RDBMS) that supports SQL execution. The techniques compile a graph pattern matching query into a SQL query that can then be executed by the relational engine. As a result, techniques enable execution of graph pattern matching queries on top of the relational engine by avoiding any change in the existing SQL engine.

Abstract: Methods for generating and utilizing a multi-modal discourse tree (MMDT) are provided herein. An extended discourse tree (EDT) may be generated (e.g., from a discourse tree (DT) or a communicative DT (CDT)) from a corpus of text. Data records (e.g., records contained numerical data) may be linked to the extended discourse tree to generate a multi-modal discourse tree. The multi-modal discourse tree may link any suitable text/records from disparate sources. For example, entities identified from elementary discourse units of the EDT may be matched to an entity of a data record. Causal links may be identified between EDTs and/or data records. Rhetorical relationships can be identified for each entity/causal link match to incorporate the data records with the EDT to generate a MMDT. The MMDT may be used to classify subsequent input, to generate answers to subsequent questions, to navigate the corpus of text and/or data records, or the like.

Abstract: The present embodiments relate to a secure boot partition for a cloud computing device of a cloud computing system. The computing device of the cloud computing system can transmit a first request for a pre-boot execution environment executable from a smart network interface card (SmartNIC). The computing device can receive the pre-boot environment executable from the SmartNIC and verify the pre-boot execution environment executable. The computing device can execute the pre-boot execution environment executable. Executing the pre-boot execution environment executable can include transmitting a second request secure boot metadata from the SmartNIC and receiving the secure boot metadata. Executing the pre-boot execution environment executable can further include mounting a boot partition, loading a boot loader obtained from the boot partition, verifying the boot loader based at least in part on the secure boot metadata, and executing the boot loader in response to verifying the boot loader.

Abstract: Herein, a computer generates and evaluates many preprocessor configurations for a window preprocessor that transforms a training timeseries dataset for an ML model. With each preprocessor configuration, the window preprocessor is configured. The window preprocessor then converts the training timeseries dataset into a configuration-specific point-based dataset that is based on the preprocessor configuration. The ML model is trained based on the configuration-specific point-based dataset to calculate a score for the preprocessor configuration. Based on the scores of the many preprocessor configurations, an optimal preprocessor configuration is selected for finally configuring the window preprocessor, after which, the window preprocessor can optimally transform a new timeseries dataset such as in an offline or online production environment such as for real-time processing of a live streaming timeseries.

Abstract: The present invention relates to optimized access of a database. Herein are techniques to accelerate execution of any combination of ad hoc query, heterogenous hardware, and fluctuating workload. In an embodiment, a computer receives a data access request for data tuples and compiles the data access request into relational operators. A particular implementation of a particular relational operator is dynamically selected from multiple interchangeable implementations. Each interchangeable implementation contains respective physical operators. A particular hardware operator for a particular physical operator is selected from multiple interchangeable hardware operators that include: a first hardware operator that executes on first processing hardware, and a second hardware operator that executes on second processing hardware that is functionally different from the first processing hardware.

Abstract: Techniques are described herein for achieving physically dispersed item-dispersal patterns in queue tables that are used as circular buffers in a FIFO system. The techniques achieve the physically dispersed item-dispersal patterns while retaining FIFO semantics, efficient data ingest, efficient data access, and low latency for both fixed and variable-size ingest data. Because consecutively inserted rows are written to physically dispersed locations on persistent storage, lock contention between concurrent ingest sessions is significantly reduced. Once a physically dispersed item-dispersal pattern is established for a first set of inserted rows, subsequent rows are added by overwriting the existing rows. The physical dispersal of the initial rows may be accomplished by setting values in a slot number column such that updates that are made in a sequence that is based on the slot number column exhibit a desired physical dispersal pattern.

Abstract: A computing device may receive a set of user documents. Data may be extracted from the documents to generate a first graph data structure with one or more initial graphs containing key-value pairs. A model may be trained on the first graph data structure to classify the pairs. Until a set of evaluation metrics for the model exceeds a set of deployment thresholds: generating, a set of evaluation metrics may be generated for the model. The set of evaluation metrics may be compared to the set of deployment thresholds. In response to a determination that the set of evaluation metrics are below the set of deployment thresholds: one or more new graphs may be generated from the one or more initial graphs in the first graph data structure to produce a second graph data structure. The first and second graph can be used to train the model.

Abstract: Embodiments implement non-intrusive load monitoring using a novel learning scheme. A trained machine learning model configured to disaggregate device energy usage from household energy usage can be stored, where the machine learning model is trained to predict energy usage for a target device from household energy usage. Household energy usage over a period of time can be received, where the household energy usage includes energy consumed by the target device and energy consumed by a plurality of other devices. Using the trained machine learning model, energy usage for the target device over the period of time can be predicted based on the received household energy usage.

Abstract: A process for defining a cloud service in an Infrastructure as Code (IaC) tool is designed to dynamically determine numbers of clusters, availability domains, compute nodes, and/or load balancers at run time. These values are then used to determine a number of subnet levels required for a classless inter-domain routing (CIDR) slicing operation to generate subnets for each of the compute nodes and load balancer nodes in the service. Because IaC languages do not provide nested loop control constructs, labels for each of the subnets can be generated and assigned using a Cartesian product of label elements. These labels can be modified by a count variable that is incremented each time a resource is duplicated in the script to simulate the effect of a nested loop structure.

Abstract: A sharded, permissioned, distributed ledger may reduce the amount of work and communication required by each participant, thus possibly avoiding scalability bottlenecks that may be inherent in previous distributed ledger implementations and possibly enabling the use of additional resources to translate to increased throughput. A sharded, permissioned, distributed ledger may be made up of multiple shards, each of which may also be a distributed ledger and which may operate in parallel. Participation within a sharded, permissioned, distributed ledger may be allowed only with permission of an authority. A sharded, permissioned, distributed ledger may include a plurality of nodes, each including a dispatcher configured to receive transaction requests from clients and to forward received requests to verifiers configured to append transactions to individual ones of the shards.

Abstract: Techniques and apparatus for data networking are described. In one example, a method includes receiving a first Layer-2 Remote Direct Memory Access (RDMA) packet which includes a virtual local area network (VLAN) tag and a quality-of-service (QoS) data field; converting the first Layer-2 RDMA packet to a first Layer-3 encapsulated packet; and forwarding the first Layer-3 encapsulated packet to a switch fabric. In this method, the converting includes adding at least one header to the first Layer-2 RDMA packet, where the at least one header includes: a virtual network identifier that is based on information from the VLAN tag, and a QoS value that is based on information from the QoS data field.

Abstract: The present disclosure relates to identifying process flows from log sources (e.g., log files), and generating visual representations (e.g., flow diagrams, Sankey diagrams, etc.) of the identified process flows. In addition, the present disclosure relates to clustering of tree structures based on the shape of the tree structure using one or more hashing algorithms. The present disclosure also relates to a user interface that presents a query builder for efficiently querying a log analytics system for tree structures that satisfy a user-defined range.

Abstract: Log data that includes a plurality of log records is asynchronously processed to validate a configuration of each log record and data included in each log record. It is determined that one or more attributes of a particular subset of log records of the plurality of log records corresponds to one or more errors. Using the particular subset, one or more enriched log records are generated by augmenting each log record of the particular subset of log records with error information that indicates one or more categories corresponding to the one or more errors. A user interface is generated to facilitate correction of the one or more errors, the user interface comprising a plurality of interactive elements corresponding to a plurality of error metrics of different categories of errors, wherein the one or more categories of the one or more errors are included in the different categories of errors.

Abstract: One or more engine instances are executed on each host to form an engine cluster. A plurality of control instances are executed on a first set of hosts to form a control cluster and comprise a control instance leader and one or more control instance followers. In response to a first host indicating a failure of a neighbor host, a pair-wise focused investigation is initiated to check peer-to-peer connections between the first host and the neighbor host. In response to one or more additional hosts indicating failures of neighbor hosts while the pair-wise focused investigation is being performed, a wide investigation is performed to check connections between the control cluster and the plurality of hosts. One or more hosts are added to an eviction list and an eviction protocol is performed to evict the one or more hosts from the engine cluster using the eviction list.

Abstract: Techniques are described for backup and restore of a thin-cloned data file. The process iterates through a plurality of memory portions of the thin-cloned data file and determines whether a memory portion of the thin-cloned data file is a memory portion with common data shared with the source data file. Without storing the common data of the shared memory portion into the thin-backup data file, the process stores placeholder metadata and corresponding reference to the shared memory portion for the thin-backup data file, in an embodiment. At restore, the process may replicate the derivative data, different from the common data, from the thin-backup data file into the thin-restored data file. For the common data, the process restores a reference for the thin-restored data file to the share memory portion, in an embodiment.

Abstract: Herein is database administration workflow automation with source annotations and intelligent scheduling techniques for applying a hierarchy of interdependent administrative tasks to distributed and/or nested databases. In an embodiment, a source language compiler analyzes annotations to identify a hierarchy of administrative tasks that administers pluggable databases in container databases. From the annotations, a runtime codebase is generated that implements and invokes the administrative task hierarchy. At runtime, a container database management system (CDBMS) autonomously identifies and instantiates the administrative tasks, including identifying a dependency of a first administrative task on a second administrative task and a lack of dependency of a third administrative task on the second administrative task.

Abstract: Operations of a search management system are disclosed. The operations may include: identifying a data corpus containing a plurality of documents, generating sets of feature vectors representing the plurality of documents, receiving a query to search the data corpus, generating a query vector for the query, identifying a target feature vector that meets a similarity threshold by comparing the query vector to the feature vectors, and presenting a query result that includes at least part of the document. The feature vectors may be generated by executing a multi-step partitioning process for partitioning a respective document into a plurality of document partitions, such that the sets of feature vectors that are generated correspond to the plurality of document partitions for the respective document. The query result may include a target partition from among the plurality of document partitions represented by the target feature vector.

Abstract: A pseudo language is provided for manipulating the complex variables associated with the orchestration flow. Verbs are specified in the pseudo language. The verbs cause operations to be performed on the complex variables during processing of the orchestration flow. A first verb of the verbs is specified with a first operation of the operations The first operation, when processed, transfers data from a first set of source elements in a source complex variable to new target elements in a target complex variable based on a description of a target schema of the target complex variable. The target complex variable does not include the first subset of source elements and the target schema includes the description of the first subset of the source elements.

Abstract: Systems, devices, and methods of the present invention detect rhetoric agreement between texts. In an example, a rhetoric agreement application accesses a multi-part initial query and generates a question communicative discourse tree that represents rhetorical relationships between fragments of the query. The application identifies a sub-communication discourse tree from the question communicative discourse tree. The application generates a candidate answer communicative discourse tree for each candidate answer of a set of candidate answers. The application computes a level of complementarity between the sub-discourse tree and each candidate answer discourse tree by applying a classification model to the sub-communication discourse tree and candidate answer communicative discourse trees. The application selects an answer from the candidate answers based on the computed complementarity, thereby building a dialogue structure of an interactive session.

Abstract: Herein is innovative control flow integrity (CFI) based on code generation techniques that instrument data protection for access control of subroutines invoked across module boundaries. This approach is counterintuitive because, even though code is stored separately from data, access control to the data is used to provide access control to the code. In an embodiment, an instrumentation computer generates, at the beginning of a subroutine that is implemented in machine instructions, a prologue that contains: a first instruction of the subroutine that indicates that the first instruction is a target of a control flow branch and a second instruction of the subroutine that verifies that a memory address is accessible. Generated in the machine instructions are instruction(s) that, when executed by a processor, cause the memory address to have limited accessibility. Some code generation may be performed at the start of runtime by a loader or a dynamic linker.

Abstract: Techniques for business-to-business (B2B) chat routing are disclosed, including: receiving, by a B2B chatbot during a chat session with a user, user input including a user-supplied business name; performing a business lookup based at least on the user-supplied business name, to obtain a canonical business name and a unique business identifier associated with the canonical business name; performing a customer relationship management (CRM) system lookup based at least on the unique business identifier, to identify a corresponding business account; routing the chat session from the B2B chatbot to a human chat agent assigned to the corresponding business account.

Abstract: An event processing system for processing events in an event stream is disclosed. The system can launch a first CQL engine in a cluster of CQL engines using a CQL engine tracking engine. The system can schedule, using the CQL engine tracking engine, the first CQL engine to process a batch of a continuous stream of input events related to an application. The system can track, using the CQL engine tracking engine, the first CQL engine to be scheduled for execution. The system can then execute, using the CQL engine tracking engine, the first CQL engine to process the batch of the continuous stream of input events to generate a set of output events related to the application.

Abstract: A method for providing for optimized service based interface (SBI) communications by performing network function (NF) fully qualified domain name (FQDN) resolution at an NF repository function (NRF) includes, at an NRF including at least one processor, receiving NF register requests including NF profiles and/or NF service profiles, at least some of which include FQDNs and do not include Internet protocol (IP) addresses. The method further includes storing the NF profiles and/or NF service profiles in an NF profiles database. The method further includes resolving the FQDNs in NF profiles and/or NF service profiles into IP addresses. The method further includes receiving NF discovery requests. The method further includes generating lists of NF profiles and/or NF service profiles that match query parameters in the NF discovery requests. The method further includes providing the lists of NF profiles and/or NF service profiles including the IP addresses to consumer NFs in NF discovery responses.

Abstract: Techniques are described for creating a network-link between a first virtual network in a first cloud environment and a second virtual network in a second cloud environment. The first virtual network in the first cloud environment is created to enable a user associated with a customer tenancy in the second cloud environment to access one or more services provided in the first cloud environment. The network-link is created based on one or more link-enabling virtual networks being deployed in the first cloud environment and the second cloud environment.

Abstract: The present disclosure relates to chatbot systems, and more particularly, to techniques for identifying an explicit invocation of a chatbot and determining an input for the chatbot being invoked. In certain embodiments, explicit invocation analysis involves detecting an invocation name in an utterance. The invocation name is an identifier assigned to a particular chatbot. In response to detection of the invocation name, the utterance is refined for input to the particular chatbot by determining which parts of the utterance, if any, contain relevant information for the particular chatbot and generating a new utterance, using the relevant parts of the utterance, for processing by the particular chatbot. The refining can involve removal of a portion of the utterance associated with the invocation name.

Abstract: Techniques for managing lifecycles of sets of foreign resources are disclosed, including: opening, in a runtime environment configured to use a garbage collector to manage memory in a heap, a memory session; allocating a first subset of a set of foreign memory to a memory segment associated with the memory session, the foreign memory including off-heap memory that is not managed by the garbage collector; encountering, in the runtime environment, an instruction to close the memory session; responsive to encountering the instruction to close the memory session, deallocating the subset of the set of foreign memory.

Abstract: Techniques discussed herein relate to implementing a distributed computing cluster (the “cluster”) including a plurality of edge devices (e.g., devices individually configured to selectively execute within an isolated computing environment). One edge device may be configured to operate as a head node of the cluster at a given time. A request for virtual resources of the cluster may be received from a user device and directed to the first edge device of the cluster. The first edge device may determine it is not operating as a head node of the cluster. The first edge device may determine that a second edge device of the cluster is operating as the head node. In response, the first edge device may forward the request to the second edge device, wherein forwarding the request to the second edge device causes the second request to be processed by the cluster.

Abstract: A shared-nothing database system is provided in which parallelism and workload balancing are increased by assigning the rows of each table to “slices”, and storing multiple copies (“duplicas”) of each slice across the persistent storage of multiple nodes of the shared-nothing database system. When the data for a table is distributed among the nodes of a shared-nothing system in this manner, requests to read data from a particular row of the table may be handled by any node that stores a duplica of the slice to which the row is assigned. For each slice, a single duplica of the slice is designated as the “primary duplica”. All DML operations (e.g. inserts, deletes, updates, etc.) that target a particular row of the table are performed by the node that has the primary duplica of the slice to which the particular row is assigned. The changes made by the DML operations are then propagated from the primary duplica to the other duplicas (“secondary duplicas”) of the same slice.

Abstract: Techniques for noise data augmentation for training chatbot systems in natural language processing. In one particular aspect, a method is provided that includes receiving a training set of utterances for training an intent classifier to identify one or more intents for one or more utterances; augmenting the training set of utterances with noise text to generate an augmented training set of utterances; and training the intent classifier using the augmented training set of utterances. The augmenting includes: obtaining the noise text from a list of words, a text corpus, a publication, a dictionary, or any combination thereof irrelevant of original text within the utterances of the training set of utterances, and incorporating the noise text within the utterances relative to the original text in the utterances of the training set of utterances at a predefined augmentation ratio to generate augmented utterances.

Abstract: Techniques for identity management, and more particularly, to techniques for dynamically assigning membership to users in the system based on dynamic rules. In one aspect a computer-implement method is provided that breaks down the processing from a single large thread or operation into multiple minutest level threads or operations and makes use of event driven architecture used in distributed environments such as a cloud environment, to achieve a scalable model and can work seamlessly for multi-tenant applications. Every sub problem is assigned to a dedicated set of subscribers on a messaging service for processing.

Abstract: A parametric constant resolves to different values in different contexts, but a single value within a particular context. An anchor constant is a parametric constant that allows for a degree of parametricity for an API point. The context for the anchor constant is provided by a caller to the API point. The anchor constant resolves to an anchor value that records specialization decisions for the API point within the provided context. Specialization decisions may include type restrictions, memory layout, and/or memory size. The anchor value together with an unspecialized type of the API point result in a specialized type of the API point. A class object representing the specialized type is created. The class object may be accessible to the caller, but the full value of the anchor value is not accessible to the caller. The API point is executed based on the specialization decisions embodied in the anchor value.

Abstract: A continuous query identified by an archived relation of an application may be received. A physical query plan may be generated for the continuous query and/or a child operator plan may be identified. A buffer operator may be inserted between the child operator and its parent operator and/or the event information from the child operator may be stored in the buffer operator. A query operator may be identified in the physical query plan. It may be determined that the query operator identified in the physical query plan is a same type as a second query operator in a second continuous query concurrently executing. Further, a combined query plan may be generated based at least in part on the query operator identified in the physical query plan being the same type as the second query operator in the second continuous query.

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: A manager file system (MFS), implemented using an OS process, exposes a path in the native file system as the root of its file system (e.g., mount point). The MFS informs the OS kernel that any file system operation whose path contains the mount point as its prefix, should be handed over to the process by invoking an appropriate interface method that the process implements as part of its file system implementation. The MFS manages one or more applications and leverages the authentication mechanism of the OS to provide fined-grained access control of MFS managed applications.

Abstract: Techniques for modifying queries in a set of nested queries are disclosed. A graphical user interface displays a query detail region alongside a nested query display region. The graphical user interface includes functionality to provide for modification of queries in the nested set of queries. Based on a selection by a user, a query modification tool promotes a query attribute from a child query to one or more parent queries. Based on another selection by a user associated with one query in the set of nested queries, the system deletes an attribute from each query in the set of nested queries. Responsive to a selection to create multiple conditions for a query rule, the system modifies the functionality of the user interface to enable entry of multiple condition characteristics. Based on a further selection, the system creates the multiple conditions for the query rule.

Abstract: Techniques discussed herein relate to managing aspects of provisioning cloud-computing edge devices. In some embodiments, a user request specifying one or more resources to be provisioned at a cloud-computing edge device may be received by a cloud-computing device operated by a cloud-computing provider. An ephemeral credential may be generated for the edge device and used to determine whether access control policies exist that enable the edge device to access the resource(s). If the resource(s) are accessible, a manifest may be generated in accordance with the user request. The manifest may specify a configuration for the cloud-computing edge device and includes information related to the resource. Operations may be subsequently executed to provision the cloud-computing edge device in accordance with the manifest. However, if the resource(s) are not accessible, the user request may be denied.

Abstract: Methods, systems, and computer readable media for validating subscriber entities against spoofing attacks in a communications network are disclosed. One method includes receiving, by a proxy element, a subscriber authentication request message that is sent from an access and mobility management function (AMF) and is directed to a unified data management (UDM) function in a home network, creating, by the proxy element, a record entry including a subscriber identifier and a public land mobile network (PLMN) identifier contained in the subscriber authentication request message, wherein the record entry is stored in an authentication registry database prior to forwarding the subscriber authentication request message to the UDM function.

Abstract: Techniques for using enhanced logit values for classifying utterances and messages input to chatbot systems in natural language processing. A method can include a chatbot system receiving an utterance generated by a user interacting with the chatbot system and inputting the utterance into a machine-learning model including a series of network layers. A final network layer of the series of network layers can include a logit function. The machine-learning model can map a first probability for a resolvable class to a first logit value using the logit function. The machine-learning model can map a second probability for a unresolvable class to an enhanced logit value. The method can also include the chatbot system classifying the utterance as the resolvable class or the unresolvable class based on the first logit value and the enhanced logit value.

Abstract: A data object has a lock and a condition indicator associated with it. Based at least partly on detecting a first setting of the condition indicator, a reader stores an indication that the reader has obtained read access to the data object in an element of a readers structure and reads the data object without acquiring the lock. A writer detects the first setting and replaces it with a second setting, indicating that the lock is to be acquired by readers before reading the data object. Prior to performing a write on the data object, the writer verifies that one or more elements of the readers structure have been cleared.

Abstract: In accordance with an embodiment, described herein is system and method for use with software application development environments, for determining attribution associated with licensed software code. The system can receive as input an indication of a source application codebase for a software application, determine dependencies on third-party modules, libraries, or other software code, and output associated license attributions for that codebase. Optionally, the system can combine and/or de-duplicate multiple sets of attributions associated with a source application codebase, or generate a set of differences between two versions of attributions, to illustrate changes between the versions. In accordance with an embodiment, if the system detects potential licensing issues associated with the use of third-party modules, libraries, or other software code, then an appropriate notification can be generated.

Abstract: Client data corresponding to a single client can be stored. A decision to proceed with a defragmentation of two or more particular core groups can be determined. A destination core group to receive client data can be identified. At least one additional core group can be initiated to manage interim data write requests from the single client. Each of the two or more particular core groups can be closed to data write requests. A defragmentation of the two or more particular core groups can be performed by merging into the destination core group. The destination core group can be availed to data read and delete requests. The two or more fragmented core groups can be reallocated for other uses. The additional core groups continue to receive read and write requests. The destination core groups further can be merged and defragmented further.