A multi-core architecture including: a plurality of processing devices, each processing device including a single processor or a cluster of processors; and a lock manager associated with each processing device, each lock manager being configured to: store a first data value indicating of whether or not it currently owns a first lock, the first lock authorizing access to a resource; and permit an owner of the first lock to be determined by one or more lock managers by broadcasting, over an interconnection network to each of the other lock managers, at least one message.

Approaches presented herein enable hot upgrading a microservices sequence in a cloud computing environment. More specifically, a next microservice of microservice subsequence in a running sequence is obtained, in response to a message to invoke the microservice or subsequence. The running microservice sequence includes at least one unexecuted microservice or subsequence that is to be hot upgraded. The running microservice sequence is generated based on a sequence that is to be hot upgraded which comprises an ordered list of microservices and/or subsequences. The approach may include determining the status of a next microservice or subsequence. The approach may further include invoking the next microservice or subsequence in the running sequence, in response to the status of the next microservice or subsequence being upgrade-complete.

A system and method of for providing assistance to complete machine learning on workflow engines that deal with machine learning flows comprising operators configured in a coordinate grid. The process analyzes the positions and composition of operators, branches, inconsistencies, collisions and redundancy in the workflow in order to suggest to the user which changes should be made to the workflow.

Systems, apparatuses, and methods for managing a number of wavefronts permitted to concurrently execute in a processing system. An apparatus includes a register file with a plurality of registers and a plurality of compute units configured to execute wavefronts. A control unit of the apparatus is configured to allow a first number of wavefronts to execute concurrently on the plurality of compute units. The control unit is configured to allow no more than a second number of wavefronts to execute concurrently on the plurality of compute units, wherein the second number is less than the first number, in response to detection that thrashing of the register file is above a threshold. The control unit is configured to detect said thrashing based at least in part on a number of registers in use by executing wavefronts that spill to memory

An apparatus in one embodiment includes at least one processing device comprising a processor coupled to a memory, with the at least one processing device being configured to maintain a replication journal for recording replication write requests in a storage system, to detect a failure impacting the replication journal, and to initiate recovery of the replication journal responsive to the detected failure. In conjunction with the recovery of the replication journal, the at least one processing device is further configured to maintain a lock contention table that characterizes lock contentions between address lock ranges required for the recovery of the replication journal and address lock ranges required by other write requests in the storage system, and to utilize the lock contention table to resolve one or more potential deadlocks that would otherwise prevent completion of the recovery of the replication journal. Other embodiments include methods and computer program products.

A method for controlling an application state, an apparatus, a terminal device and a non-transitory computer-readable storage medium are disclosed. The method may include: unfreezing a target application currently to be called in response to a determination that the target application is in a frozen state and a current call meets an application unfreezing trigger condition.

A method of detecting race conditions in a service based communication architecture network (600) comprising a Message Broker, MB, function (210) mediating messages, relating to service procedures, between one or more services available to a User Equipment, UE, (11) communicating within the service based communication architecture network (600). The method comprising receiving, by the MB (210), from the services, a message relating to at least one of start and end of a service procedure. Determining, by the MB (210), based on the received message, that the service procedure causes a race condition, and intervening, upon detection of a race condition, in executing the service procedures. There is also provided a Message Broker, MB, function (210) arranged for detecting and handling race conditions, a communication network (600) comprising an integrated message broker and race condition handler (210) and a computer program product.

Managing concurrent accesses by a set of tasks to a shared resource of a computer system. Synchronizing the set of tasks for assigning and releasing a resource according to a predefined access period with flexibility of providing an extended access period where an external task is not detected during the predefined access period. Where an extended access period is provided, resynchronizing is performed, and the external task is identified and access is prevented when the external task is determined to be a particular type of task.

An approach for preventing deadlocks when calling a plurality of web services in a single transaction. The approach receives a list of service definitions from a client to call as a single unit of work (UOW). The approach sorts, based on applying a predetermined ordering rule, the list into a standardized order list. The approach sends the standardized order list to the client for execution.

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.