Abstract: A system can establish a primary file system on a block array of computer storage, wherein the block array comprises a range of addresses, wherein the primary file system is configured to address the range of addresses. The system can establish a shadowed file system on the block array, wherein the shadowed file system is configured to access portions of the block array that are unused by the primary file system. The system can, in response to receiving a request to write data to the primary file system, and in response to determining that an amount of the block array utilized by the primary file system is full, transfer a first portion of the block array utilized by the shadowed file system to the primary file system.

Abstract: The present invention provides a system, computer readable code and method for dynamically performing debugging. The system, code, and method store debugging logs throughout an operation. At predetermined points the logs are stored to a cache. Older and/or unnecessary logs are periodically deleted from the cache to ensure that the cache does not grow to be larger than a predetermined size. This avoids the need to re-run a scenario after an error occurs in order to produce troubleshooting/debugging information.

Abstract: A method includes receiving trace data representing access information about files stored in a large-scale distributed storage system, identifying file access patterns based on the trace data, receiving metadata information associated with the files stored in the large-scale distributed storage system, and generating a preferred storage parameter for each file based on the received metadata information and the identified file access patterns. The method also includes receiving, file reliability or accessibility information of a new file, determining whether the received file reliability or accessibility information of the new file matches information of a file group of the files in the large-scale distributed storage system, and when the file reliability or accessibility information of the new file matches the information of the file group, storing the new file in the large-scale distributed storage system using the preferred storage parameter associated with the file group.

Abstract: A method for snapshot reversion, the method may include initializing a recovery of a storage system, from a failure that stopped a replication of a failed replication snapshot to an other storage system; wherein the other storage system reverted to an older snapshot not stored in the storage system; and reverting to the older snapshot, by the storage system using older snapshot metadata and data received from the storage system; wherein the older snapshot data may include a non-existing indication for a snapshot segment that existed in a snapshot that followed the older snapshot and not exists at the older snapshot, and wherein the data may include one or more older snapshot segments; wherein the reverting to the older snapshot is executed without undoing changes that were made since the older snapshot.

Abstract: Updates for transactions to a replication log for a database may be amortized. As updates are received as part of an active transaction, replication log records may be generated. When the size of replication log records exceeds a transaction size threshold, the replication log records may be stored in a remote data store instead of a local data store. When a request to commit the active transaction is received, an replication log for the database may be updated to include the replication log records from a transaction data object in the remote data store.

Abstract: According to certain aspects, a secondary computing system can be configured to perform a full backup on database data, generate incremental backups comprising log files associated with modifications to the database data, and create a differential full backup copy of the database data using the full backup copy and changed blocks identified using the log files from the incremental backups.

Abstract: Selectively committing or rolling-back in-flight units of recovery is provided. An indicator is read in a transaction identifier information record corresponding to a unit of recovery that is in-flight. It is determined whether the indicator indicates a commit for the unit of recovery that is in-flight. In response determining that the indicator does indicate the commit for the unit of recovery that is in-flight, the unit of recovery that is in-flight corresponding to the transaction identifier information record is committed to form a committed unit of recovery. The committed unit of recovery corresponding to the transaction identifier information record is sent to a target system for further processing.

Abstract: An automated method is provided for resolving an unintended transaction rollback in a system that includes an audited database, a non-audited application, and a facility for converting non-audited applications to use audited database transactions, wherein the unintended transaction rollback is the result of a failure of the facility to convert the unintended transaction rollback to a commit operation, The non-audited application is operated with the facility creating database transactions against the audited database. The database transactions include one or more transaction steps or operations. The created database transactions are monitored to detect transaction rollbacks. A determination is made when a detected transaction rollback for a database transaction is an unintended transaction rollback. The one or more transaction steps or operations of the database transaction that included the unintended transaction rollback are recovered in the audited database.

Abstract: An exemplary embodiment of the present disclosure discloses a computer program stored a non-transitory computer readable storage medium. When the computer program is executed by one or more processors, the computer program performs operations for Change Data Capture (CDC) by one or more processors, and the operations include: extracting a change data from at least one redo log of an online redo log and an archive redo log; analyzing at least one information of a resource utilization rate information and a remain log information of a source database server; and determining to process the change data in one mode of a first mode saving the change data as a CDC file and a second mode recording the change data in a memory, based on at least one of the remain log information and the resource utilization rate information.

Abstract: A method for synchronizing a local file system (LFS) and a remote (cloud) file system (RFS) includes the step of storing events indicative of differences between the LFS and the RFS, where the events are associated with file system objects of the LFS and RFS. The method further includes the steps of prioritizing the events, generating file system operations for the events based at least in part on the prioritization of the events, and performing at least some of the file system operations to synchronize the LFS and RFS. Prioritizing the events includes defining a plurality of service classes (e.g., based on type of event, event attribute, etc.), assigning a priority to each of the service classes, and assigning each event to one of said service classes. Systems are also described. The invention allocates limited synchronization resources based on a predefined policy to synchronize important file system objects sooner.

Abstract: Various embodiments set forth techniques for transactional allocation and deallocation of blocks in a block store. A first technique includes sending a first request that causes a non-persistent allocation of a block. The first technique also includes adding a first entry in a log recording the allocation as tentative, sending a second request that causes persistence of the allocation, and adding a second entry in a log recording the allocation as finalized. A second technique includes adding a first entry in a log recording a deallocation of a block, sending a first request that causes the deallocation of the block and causes the block to be unavailable for reallocation in a non-persistent manner, adding a second entry in the log recording that the deallocation is finalized, and sending a second request that causes the block to be made available for reallocation.

Abstract: Systems and methods for reducing latency in transactions are described herein. In an embodiment, an application edge acts as a system of record for an application. When a client computing device sends a request to perform a transaction to the application, the application edge receives the request and, without forwarding the request to a backend computing network, searches a transaction datastore stored at the application edge for the account balance and responds to the client computing device with the account balance. The client computing device then determines that a transaction can be performed and sends a request to perform the transaction to the application. The application edge passes this request to the backend computing network which performs the requested transaction. The application edge then uses a webhook infrastructure to update each transaction datastore stored at the application edge.

Abstract: The embodiments described herein describe technologies for non-volatile memory persistence in a multi-tiered memory system including two or more memory technologies for volatile memory and non-volatile memory.

Abstract: The described methods, systems, and other aspects can, by way of example, advantageously provide efficient metadata storage in a master-slave node-based metadata store of a distributed storage system. An example method may write a first transaction entry in a transaction log of a first node based on a first request for a first operation associated with a first storage object. The method may then request a second node write the first transaction entry in a transaction log of the second node based on the first request. While awaiting a first acknowledgment of a completion of a writing of the first transaction entry in the transaction log of the second node, the method may proceed to write one or more subsequent transaction entries in the transaction log of the first node based on one or more subsequent requests for one or more operations associated with one or more storage objects.

Abstract: The subject technology receives a cross domain transaction, the cross domain transaction including a plurality of statements. The subject technology sends a first statement to an execution node for executing the first statement on first storage using micro-partitions. The subject technology sends a second statement to the execution node for executing the second statement on linearizable storage. The subject technology updates, using a metadata database, a status of the cross domain transaction to a pre-commit state. The subject technology sends a request to prepare a commit of the cross domain transaction. The subject technology updates, using the metadata database, the status of the cross domain transaction to a committing state. The subject technology finalizes the commit of the cross domain transaction and updating second metadata that the cross domain transaction has been committed.

Abstract: The present technology relates to a memory controller according to an embodiment includes a map caching controller generating a slot allocation request to allocate a physical slot in which a first map segment is to be stored among a plurality of physical slots, a map buffer manager outputting the first map segment, first physical slot information, and tree slot information, in response to the slot allocation request, and a mapping manager receiving the first map segment, the first physical slot information, and the tree slot information, deleting a second map segment and second physical slot information stored in a tree slot among a plurality of tree slots of a map tree, and storing the first map segment and the first physical slot information in the tree slot. At least one of the second map segment and the second physical slot information stored in the tree slot is invalid.

Abstract: An automated method is provided for replacing a currently operating data replication engine with a new data replication engine. The currently operating data replication engine replicates source database transactions including any new source database transactions committed in an audit trail of the source database before the currently operating data replication engine stops replicating. All new source database transactions that the currently operating data replication engine has not completed replicating are joined. The currently operating data replication engine is stopped when all of the source database transactions that were not joined have completed replicating. All joined transactions are then voted to be committed and are replicated. The new data replication engine replicates all new source database transactions started after the currently operating data replication engine stops.

Abstract: Embodiments of the present invention provide a new multi-level data structure, log-structured merge bush (LSM-bush), to alleviate the performance compromise between LSH-table and LSM-tree data structures. Similar to LSM-tree, LSM-bush may buffer writes in memory, merge the writes as sorted runs across multiple levels in storage, and use in-memory fence pointers and Bloom filters to facilitate lookups. LSM-bush differs from LSM-tree in that it allows newer data to be merged more “lazily” than LSM-tree. This can be achieved by allowing larger numbers of runs to be collected at the smaller levels before merging them.

Abstract: Example implementations described herein are directed to systems and methods to accelerating the time to identify the latest snapshot that is not infected by malware and swap the snapshot for an underlying volume for a host computer without needing to communicate with the storage administrator of the storage system. In example implementations described herein, an iterative process is utilized to traverse snapshots through a storage plug-in application until such a snapshot is identified. Through the example implementations described herein, such snapshots can be identified quickly in comparison to manual selection.

Abstract: A method is used in improving rebuilding in data storage. The generation number of a PLB is compared with a generation number of a partition corresponding to the PLB. The data of the PLB is rebuilt based on the comparison.

Abstract: Disclosed are techniques for migrating the execution of a task from a first host system to a second host system by copying a snapshot of data required for starting the execution of a task from memory of the first host system to memory of a coupling facility, monitoring the execution of the task on the first host system, and, upon detecting failure of the execution of the task on the first host system, initiating execution of the task on the second host system by copying the snapshot of data from the memory of the coupling facility to the memory of the second host system.

Abstract: A method to dynamically optimize utilization of data transfer techniques includes processing multiple I/O requests using one of several data transfer techniques depending on which data transfer technique is more efficient. The data transfer techniques include: a memory copy data transfer technique that copies cache segments associated with an I/O request from a cache memory to a permanently mapped memory; and a memory mapping data transfer technique that temporarily maps cache segments associated with an I/O request. In order to process the I/O requests, the method utilizes a first number of “copy” windows associated with the memory copy data transfer technique, and a second number of “mapping” windows associated with the memory mapping data transfer technique. The method dynamically adjusts one or more of the first number and the second number to optimize the processing of the I/O requests. A corresponding system and computer program product are also disclosed.

Abstract: Automated devices send messages of a first batch sequence individually to a target queue of a receiving node of a cluster of server nodes, the messages having a different sequence number indicative of their relative positions within the batch sequence, and each is associated with a first logic unit of work identifier. In response to determining that a message counter meets a threshold, a force commit packet is generated to include the sequence number of the last batch message sent to the target queue. If the force commit packet sequence number is not the last position number within the batch sequence, a second logic unit of work identifier is associated with a subset sequence of the batch of messages having sequence numbers spanning from the first number to the force commit packet sequence number, and the subset sequence messages are committed to the receiving node target queue.

Abstract: A method for tracking objects in a first memory during a plurality of time intervals is provided, wherein the method comprises: updating, by one or more update threads, copying, by the one or more test threads, the one or more non-copied shadow objects to a second memory, determining, by the one or more test threads whether the step of copying the one or more non-copied shadow objects was successful, and updating, by the one or more test threads, the status variables of corresponding objects that correspond to the one or more non-copied shadow objects that were copied successfully, wherein subsequent bits of the status variables correspond to subsequent time intervals and wherein the one or more update threads and the one or more test threads operate on disjoint sets of bits of the status variables.

Abstract: Automated devices send messages of a first batch sequence individually to a target queue of a receiving node of a cluster of server nodes, the messages having a different sequence number indicative of their relative positions within the batch sequence, and each is associated with a first logic unit of work identifier. In response to determining that a message counter meets a threshold, a force commit packet is generated to include the sequence number of the last batch message sent to the target queue. If the force commit packet sequence number is not the last position number within the batch sequence, a second logic unit of work identifier is associated with a subset sequence of the batch of messages having sequence numbers spanning from the first number to the force commit packet sequence number, and the subset sequence messages are committed to the receiving node target queue.

Abstract: Techniques for efficiently swizzling pointers in persistent objects are provided. In one embodiment, a computer system can allocate slabs in a persistent heap, where the persistent heap resides on a byte-addressable persistent memory of the system, and where each slab is a continuous memory segment of the persistent heap that is configured to store instances of an object type used by an application. The system can further store associations between the slabs and their respective object types, and information indicating the locations of pointers in each object type. At the time of a system restart or crash recovery, the system can iterate through each slab and determine, based on the stored associations, the slab's object type. The system can then scan though the allocated objects in the slab and, if the system determines that the object includes any pointers based on the stored pointer location information, can swizzle each pointer.

Abstract: Facility for providing backup and restore of all data center components including physical machines, virtual machines, routers, networks, sub-networks, switches, firewall, directory lookup, DNS, DHCP and internet access. Virtual or physical machines are associated to data center components and a software defined network, storage, and compute infrastructure is provided.

Abstract: Exemplary embodiments provide a hybrid buffer pool for a database that includes a plurality of data pages contained in storage. The hybrid buffer pool comprises: a shared buffer pool of page frames containing dirty data pages that are modified after reading that will be written back to storage; an immutable buffer pool that temporarily contains read-only data pages from the storage; and a page multiplexer that identifies which ones of the data pages from storage to store in the immutable buffer pool based at least in part on information from a query processor.

Abstract: A system and method for updating, monitoring, and controlling applications on a workstation. The workstation includes a workstation management module configured to detect the launch or request to access a network by an application. A workstation application server receives data associated with the application from the workstation. The application server module can determine one or more policies or categories to associate with the application by referencing an application inventory database. Once the application server module has the category or policy, it forwards a hash/policy table to the workstation management module. Upon receipt of the hash/policy table, the workstation management module applies the policy that is associated with the application to control network access by the application.

Abstract: An approach to providing failure protection in a loosely-coupled cluster environment. A node in the cluster generates checkpoints of application data in a consistent state for an application that is running on a first node in the cluster. The node sends the checkpoint to one or more of the other nodes in the cluster. The node may also generate log entries of changes in the application data that occur between checkpoints of the application data. The node may send the log entries to other nodes in the cluster. The node may similarly receive external checkpoints and external log entries from other nodes in the cluster. In response to a node failure, the node may start an application on the failed node and recover the application using the external checkpoints and external log entries for the application.

Abstract: Databases of an active node and a standby node of a main memory database management system (MMDBMS) are managed so as to prevent loss of a transaction caused by failure of any one of the active node or the standby node. The MMDBMS is configured to prevent data mismatch between the active node and the standby node when failure of any one of the active node and the standby node occurs. In case of failure of one of the nodes, log information from the other node is obtained to recover the failed node.

Abstract: A transactional system can utilize the distributed storage and high availability (HA) capability provided by a clustered database to support easy and feasible disaster recovery. The transactional middleware machine environment comprises one or more transactional application servers associated with a transaction. The one or more transactional application servers operate to persist transactional log information associated with the transaction in a database that connects with said one or more transactional application servers at a local site. The database at the local site operates to replicate the persisted transactional log information to a remote database at a remote site. The remote database allows a different transactional application server at the remote site to recover the persisted transactional log information and complete the transaction, when a disaster disables the local site.

Abstract: A computer usable program product for accelerating recovery in an MPI environment is provided in the illustrative embodiments. A first portion of a distributed application executes using a first processor and a second portion using a second processor in a distributed computing environment. After a failure of operation of the first portion, the first portion is restored to a checkpoint. A first part of the first portion is distributed to a third processor and a second part to a fourth processor. A computation of the first portion is performed using the first and the second parts in parallel. A first message is computed in the first portion and sent to the second portion, the message having been initially computed after a time of the checkpoint. A second message is replayed from the second portion without computing the second message in the second portion.

Abstract: A cluster server manages allocation of free blocks to cluster clients performing writes in a clustered file system. The cluster server manages free block allocation with a free block map and an in-flight block map. The free block map is a data structure or hardware structure with data that indicates blocks or extents of the clustered file system that can be allocated to a client for the client to write data. The in-flight block map is a data structure or hardware structure with data that indicates blocks that have been allocated to clients, but remain in-flight. A block remains in-flight until the clustered file system metadata has been updated to reflect a write performed to that block by a client. After a consistency snapshot of the metadata is published to the storage resources, the data at the block will be visible to other nodes of the cluster.

Abstract: Techniques are disclosed that include a computer-implemented method, including storing information related to an initial state of a process upon being initialized, wherein execution of the process includes executing at least one execution phase and upon completion of the executing of the execution phase storing information representative of an end state of the execution phase; aborting execution of the process in response to a predetermined event; and resuming execution of the process from one of the saved initial and end states without needing to shut down the process.

Abstract: A data file on a storage media is processed during playback or execution to identify unreadable data. Replacement data corresponding to the unreadable data is obtained over a communications network, and the replacement data is used to playback or execute the data file as if the data file does not contain any unreadable data.

Abstract: Application-level replication, the synchronization of data updates within a cluster of application servers, may be provided by having application servers themselves synchronize all updates to multiple redundant databases, precluding the need for database-level replication. This may be accomplished by first sending a set of database modifications requested by the transaction to a first database. Then a message may be placed in one or more message queues, the message indicating the objects inserted, updated, or deleted in the transaction. Then a commit command may be sent to the first database. The set of database modifications and a commit command may then be sent to a second database. This allows for transparent synchronization of the databases and quick recovery from a database failure, while imposing little performance or network overhead.

Abstract: Several methods and a system for analyzing ordered data using pattern matching over an indefinitely long ordered sequence of rows in a relational database are disclosed. In one embodiment, a method of a server includes receiving an ordered data in a relational database. The method further includes matching a pattern specified in a query on ordered data in a relational database in a single pass in constant space for overlapping mode of results. The method also includes creating an output data in the single pass in constant space for overlapping mode of results based on the matching of the ordered data with the pattern in the relational database query.

Abstract: Shared storage systems and methods are provided. A particular shared storage system is a system including multiple instances of shared storage. Each of the instances of shared storage includes data and file system metadata separated from the data. The file system metadata includes location data specifying storage location information related to the data. A persistent common view is provided of local and remote files, file systems, and services in the shared storage.

Abstract: Disaster recovery is performed based on journaling events prioritization in information in an information technology environment. One implementation involves prioritizing log file events for scheduling of jobs on a computing system, by logging events concerning each job execution plan, in a log file, and for disaster recovery, prioritizing logged events based on corresponding job urgency and relevance level and performing recovery by reapplying the events of log files in the priority order such that more urgent and relevant jobs are recovered first.

Abstract: A computer system for managing log information, enabling correct comprehension of system logs for an identical resource before and after migration among plural nodes. A global ID, being unique in the system, is given to a resource (LU) migrated from one file share server to another. The global ID remains the same in the migration destination file share server after migration and log messages for the resource are obtained based on the global ID.

Abstract: Provided are a method, system, and article of manufacture for checkpointing and restoring user space data structures used by an application accessing a data structure maintained by an operating system for an executing application. Information in the accessed data structure is saved with checkpoint information for the application. An operation to restore the application from the checkpoint information is initialized. A restored data structure is generated to include the saved information in the accessed data structure saved in the checkpoint information in response to restoring the application. An initialization routine of the application is modified to bypass initializing the data structure as part of the application initialization routine to restore the application.

Abstract: A method is provided for the recovery of an instance of a job manager running on one of a plurality of nodes used to execute the processing elements associated with jobs that are executed within a cooperative data stream processing system. The states of the processing elements are checkpointed to a persistence mechanism in communication with the job manager. From the checkpointed processing element states, the state of each distributed job is determined and checkpointed. Processing element states are also checkpointed locally to the nodes one which the processing elements are running. Following a failure of the job manager, the job manager is reinstantiated on one of the nodes. The recovery instance of the job manger obtains state data for processing elements and jobs from the persistence mechanism and constructs an initial state for jobs and processing elements. These initial states are reconciled against the current states of the processing elements and adjustments are made accordingly.