Multi-version processing using monitor subsystem

The monitor subsystem manages version compatibility of the sequencing system, and solves the compatibility problem of different versions of client applications on the server device, achieving stable and efficient operation of the system.

CN118901103AActive Publication Date: 2024-11-05ILLUMINA INC
View PDF 5 Cites 0 Cited by

Patent Information

Application Number
CN202380028880.0
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Priority Date
2022-09-20
Filing Date
2023-09-13
Publication Date
2024-11-05
Estimated Expiration
2043-09-13

AI Technical Summary

Technical Problem

Existing sequencing systems are difficult to support different versions of client software applications on server devices, resulting in version compatibility issues and affecting the stability and efficiency of the system.

Method used

Introduce a monitor subsystem to allow or block access by identifying the version compatibility between the client and the server side, preventing version incompatible clients from requesting access to the server subsystem, and replacing the version when the server subsystem is idle to handle requests for other versions .

Benefits of technology

It realizes effective management of client requests on different versions, ensures system stability and efficiency, avoids access problems caused by version compatibility, and improves system flexibility and reliability.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118901103A_ABST
    Figure CN118901103A_ABST
Patent Text Reader

Abstract

A version of a sequencing system may be monitored to enable a version of a server subsystem operating the sequencing system to be changed to serve requests from a client subsystem for performing analysis of sequencing data. The monitor subsystem may be used to receive and authorize requests from the client subsystem. The monitor subsystem may identify a version associated with a server subsystem operating the sequencing system to be implemented to serve the request. When the version associated with the client subsystem and the version associated with the server subsystem are compatible, the monitor subsystem may allow access to the server subsystem to serve the request from the client subsystem. The monitor subsystem may prevent the server subsystem from being accessed when the version associated with the client subsystem and the version associated with the server subsystem are incompatible.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims the benefit of U.S. Provisional Patent Application No. 63 / 408,235, filed on September 20, 2022, which is incorporated herein by reference in its entirety. Background Art

[0003] The sequencing platform provides fast and accurate secondary and tertiary genomic analysis of sequencing data. The platform can span hardware and software to provide a complete sequencing solution. In a single process (SP) environment, a single application can run on a single field programmable gate array (FPGA) installed on a server device at a time. A single version of the software can be installed on a server device at a given time. Users with specific version requirements can install their desired software version and run their application.

[0004] In a multi-process (MP) environment, multiple applications can run simultaneously on a set of FPGA hardware. Several users can run sequencing jobs simultaneously. Because sequencing solutions can span multiple layers of software and hardware, it is difficult to support client software applications that execute different versions of sequencing software on server devices. Summary of the invention

[0005] Described herein is a system, method, and apparatus for monitoring the version of a sequencing system so that the version of a server subsystem operating the sequencing system can be changed to serve a request from a client subsystem for performing an analysis of sequencing data. A monitor subsystem can be used to receive a request from a client subsystem. The request can include a version associated with the client subsystem from which the request is received. The monitor subsystem can identify a version associated with a server subsystem operating the sequencing system to be implemented to serve the request. When the version associated with the client subsystem is compatible with the version associated with the server subsystem, the monitor subsystem can allow access to the server subsystem to serve the request from the client subsystem. When the version associated with the client subsystem is incompatible with the version associated with the server subsystem, the monitor subsystem can prevent the server subsystem from being accessed. The monitor subsystem can identify a change in the version associated with the server subsystem to authorize a request from a client subsystem that has previously been blocked from accessing the server subsystem due to version incompatibility.

[0006] The monitor subsystem may continue to authorize requests from client subsystems associated with the compatible version while the server subsystem continues to operate the same version of the sequencing application. When the monitor subsystem determines that the server subsystem or a process operating thereon is idle, the monitor subsystem may cause the server subsystem to change the version used to process requests from client subsystems operating with other versions of the sequencing application. The change from the first version to the second version includes tearing down and building up at least one software layer in the vertical solution stack.

[0007] Each version of the server subsystem can include different features for bioinformatics components associated with processing different requests. Different bioinformatics components can be utilized by loading different bioinformatics components into one or more field programmable gate arrays (FPGAs). Different versions of the server subsystem can support loading different bioinformatics components onto one or more FPGAs to support the same or different sequencing tasks. Sequencing tasks can include tasks performed in secondary or tertiary analysis of sequencing data. Secondary or tertiary analysis includes alignment, sorting, or variant detection based on sequencing data.

[0008] The monitor subsystem may be a daemon process. The server subsystem may be a daemon process that operates at least partially on a client device or a server device. The daemon process may be one of a plurality of predefined daemons in the server subsystem.

[0009] The monitor subsystem may prevent the server subsystem from being accessed by the client subsystem by preventing the access key from being transmitted to the client subsystem or preventing a connection from being established between the client subsystem and the server subsystem. The monitor subsystem may allow the server subsystem to be accessed by the client subsystem by providing the access key to the client subsystem. The monitor subsystem may notify the server subsystem that the access key has been provided to the client subsystem.

[0010] The client subsystem may receive a message indicating that the client subsystem has been blocked. The client subsystem may wait to receive an indication from the monitor subsystem indicating that the request can be processed. The client subsystem may receive an access key and transmit a message including the access key for establishing a connection with the server subsystem to the server subsystem.

[0011] The request may be received by the monitor subsystem from the client subsystem via a socket. Access to the server subsystem may be granted through the socket via an access key. The monitor subsystem may monitor signals from the child process to detect a terminal signal for restarting the child process. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] Figure 1A A schematic diagram showing the system environment is shown.

[0013] Figure 1B is a diagram illustrating a system including a monitor subsystem that can be used to manage requests from client sequencing applications on client subsystems operating on different versions.

[0014] Figure 1C Examples of one or more bioinformatics subsystems that may be implemented by a sequencing system operating on a server subsystem for performing secondary and / or tertiary forms of sequencing analysis are shown.

[0015] Figure 2 is a flow chart depicting an exemplary process for monitoring versions of a server subsystem and processing requests from compatible client subsystems.

[0016] Figure 3 is a block diagram of an exemplary computing device. DETAILED DESCRIPTION

[0017] Figure 1A A schematic diagram of a system environment (or "environment") 100 as described herein is shown. As shown, the environment 100 includes one or more server devices 102 connected to one or more client devices 108 and sequencing devices 114 via a network 112.

[0018] like Figure 1A As shown, the server device 102, the client device 108, and the sequencing device 114 can communicate with each other via the network 112. The network 112 may include any suitable network on which computing devices can communicate. The network 112 may include a wired and / or wireless communication network. An exemplary wireless communication network may include one or more types of radio frequency (RF) communication signals using one or more wireless communication protocols (such as a cellular communication protocol, a wireless local area network (WLAN) or a WIFI communication protocol, and / or another wireless communication protocol). In addition to or in lieu of communicating across the network 112, the server device 102, the client device 108, and / or the sequencing device 114 may bypass the network 112 and may communicate directly with each other.

[0019] like Figure 1A As further illustrated, the environment 100 may include a database 116. The database 116 may store information for access by devices in the environment 100. The server device 102, the client device 108, and / or the sequencing device 114 may communicate with the database 116 (e.g., directly or via the network 112) to store and / or access information.

[0020] like Figure 1AAs indicated, the sequencing device 114 may include a device for sequencing a biological sample. The biological sample may include human and / or non-human deoxyribonucleic acid (DNA) to determine a single nucleotide base of a nucleic acid sequence (e.g., by synthetic sequencing). The biological sample may include human and / or non-human ribonucleic acid (RNA). The sequencing device 114 may analyze nucleic acid fragments and / or oligonucleotides extracted from the sample to generate nucleotide reads and / or other data directly or indirectly on the sequencing device 114 using the computer-implemented methods and systems described herein. More specifically, the sequencing device 114 may receive and analyze the nucleic acid sequence extracted from the sample in a nucleotide sample slide (e.g., a flow cell). The sequencing device 114 may utilize synthetic sequencing ("SBS") to sequence nucleic acid fragments into nucleotide reads.

[0021] like Figure 1A As further indicated, the server device 102 may generate, receive, analyze, store and / or transmit digital data, such as data used to determine nucleotide base calls or sequence nucleic acid polymers. Figure 1A As shown, the sequencing device 114 can generate and send (and the server device 102 can receive) nucleotide reads and / or other sequencing data for analysis by the server device 102 for base calling and / or variant calling. The server device 102 can also communicate with the client device 108. Specifically, the server device 102 can send data, including sequencing data or other information, to the client device 108, and the server device 102 can receive input from the user via the client device 108.

[0022] Server device 102 may comprise a distributed server collection, where server device 102 includes multiple server devices distributed across network 112 and located in the same or different physical locations. Further, server device 102 may comprise a content server, an application server, a communication server, a web hosting server, or another type of server.

[0023] like Figure 1A As further shown, the server device 102 and / or the sequencing device 114 may include a server subsystem 104. The server subsystem 104 may include software and / or hardware used by the server device 102 to process sequencing requests and / or data, as described herein. The server subsystem 104 may be included in a single server device 102 or sequencing device 114, or may be distributed across multiple devices. The server subsystem 104 may include a sequencing system across multiple layers of software and / or hardware for servicing requests for sequencing services at the server subsystem 104.

[0024] The server subsystem 104 may analyze the nucleotide reads and / or other data, such as sequencing metrics, received from the sequencing device 114 to determine the nucleotide base sequence of the nucleic acid polymer. For example, the server subsystem 104 may receive raw data from the sequencing device 114 and may determine the nucleotide base sequence of the nucleic acid fragment. The server subsystem 104 may process the sequencing data to determine the sequence of the nucleotide bases in the DNA and / or RNA fragments or oligonucleotides. In addition to processing and determining the sequence for the biological sample, the server subsystem 104 may also generate files for processing and / or transmission to other devices.

[0025] Each client device 108 may generate, store, receive and / or transmit digital data. Specifically, the client device 108 may receive sequencing metrics from the sequencing device 114. In addition, the client device 108 may communicate with the server device 102 to receive one or more files containing nucleotide base calls and / or other metrics. The client device 108 may present or display information related to nucleotide base calls to a user associated with the client device 108 within a graphical user interface.

[0026] Figure 1A The illustrated client device 108 may include various types of client devices. For example, the client device 108 may include a non-mobile device, such as a desktop computer or a server, or other types of client devices. In other examples, the client device 108 may include a mobile device, such as a laptop, a tablet computer, a mobile phone, or a smart phone.

[0027] like Figure 1A As further illustrated, each client device 108 may include one or more client subsystems 110. The server device 102 and / or sequencing device 114 may also or alternatively include one or more client subsystems. Each client subsystem 110 may include software and / or hardware used by a client process to process sequencing requests and / or data, as described herein. The client subsystem 110 may span multiple layers of software and / or hardware. The client subsystem 110 may be included in a single device or may be distributed across multiple devices.

[0028] The client subsystem 110 may include a sequencing application. The sequencing application may be a remote application or a local application stored and executed on a local device. The sequencing application may include instructions that, when executed, cause the client device 108 to receive data from the sequencing device 114 and / or the server device 102 and present the data to a user of the client device 108 for display at the client device 108.

[0029] A plurality of client requests from the client subsystem 110 may be received at the server subsystem 104 for performing sequencing services. The client subsystem 110 transmitting the request may operate using different versions of a sequencing application for analyzing sequencing data. In one example, different versions of the sequencing application may support different types of analysis for the same or different types of sequencing devices 144. The server subsystem 104 of the server device 102 may load and execute different versions of the sequencing system to support client sequencing applications operating on different versions of software at the client subsystem 110. Different versions of the sequencing system may span multiple layers of software and / or hardware of the server subsystem 104. For example, different versions of the sequencing system may span multiple software and / or hardware layers of a vertical solution stack.

[0030] The monitor subsystem may be used to appropriately manage requests received at the server subsystem 104 from the client subsystems 110 operating on different versions of the software. Figure 1B 1 is a diagram illustrating a system 100a including a monitor subsystem 120 that can be used to manage requests from client sequencing applications on client subsystems 110a, 110b operating on different versions. For example, the monitor subsystem 120 can receive a request 150 from the client subsystem 110a and a request 152 from the client subsystem 110b. The client subsystems 110a, 110b may each communicate with the monitor subsystem 120 via a standard Berkley (BSD) socket, address (e.g., IP address and port), or another communication interface accessible via function calls as an endpoint for sending and / or receiving information. The client subsystems 110a, 110b may execute sequencing applications operating on different versions of software. The monitor subsystem 120 may be a daemon or other background process executed on one or more server devices 102, one or more sequencing devices 114, one or more client devices 108, and / or distributed across the server devices 102, sequencing devices 114, and / or client devices 108. The monitor subsystem 120 may be capable of managing requests 150, 152 for services to be performed by the server subsystem 104 to allow the server subsystem 104 to load and execute different versions of software for operating a sequencing system to support the services in each of the requests 150, 152.

[0031] The requests 150, 152 may each include a version identifier, a product identifier, or other information associated with the respective client subsystem 110a, 110b and / or the sequencing application from which each request 150, 152 is received. The monitor subsystem 120 may use the version identifier, product identifier, and / or other information in the request 150 to identify the version that the client subsystem 110a is using for operations of the sequencing application executed thereon. The monitor subsystem 120 may use the version identifier, product identifier, and / or other information in the request 152 to identify the version that the client subsystem 110b is using for operations of the sequencing application executed thereon.

[0032] The monitor subsystem 120 may be started when the sequencing system and / or the device on which the monitor subsystem 120 is installed is started. The monitor subsystem 120 may monitor the version of the sequencing system installed on the server subsystem 104 (which may be referred to as the version of the server subsystem 104) to determine whether the version of the sequencing system installed on the server subsystem 104 is compatible with the version of the client subsystem 110a, 110b and / or the application executed thereon from which the request 150, 152 is being received. The compatible version may be stored in a file in the memory for reference by the monitor subsystem 120. When an updated version of the sequencing system is installed in the memory on one or more devices on which the server subsystem is installed, the file may be updated to identify the compatible version of the client subsystem. The monitor subsystem 120 may communicate with one or more processes on the server subsystem 104 to identify the version of one or more layers of software and / or hardware installed in the sequencing system. For example, the server subsystem 104 may program each layer of software and / or hardware in the vertical solution stack according to different versions of the sequencing system.

[0033] In one example, the software layer of the server subsystem 104 may include a daemon 160 with which the monitor subsystem 120 can communicate. The daemon 160 may be a background process executed on one or more devices (e.g., the server device 102, the sequencing device 114, and / or the client device 108). The daemon 160 may manage hardware on one or more devices (e.g., the server device 102, the sequencing device 114, and / or the client device 108) in response to a request from a client subsystem operating with a compatible version of the sequencing application. The daemon 160 may be a subservice of the monitor subsystem 120 that is started by the monitor subsystem 120. The monitor subsystem 120 may start and monitor its subprocesses during its operation. If any subprocess dies unexpectedly, the monitor subsystem 120 may detect the loss and restart the subprocess. The monitor subsystem 120 is able to tear down and establish services for each layer during version switching by sending commands to one or more subprocesses (e.g., the daemon 160, the daemon permission process 163, and / or the daemon 164). The monitor subsystem 120 may query the daemon process 160 for the versions of the software and / or hardware layers in the vertical solution stack. As another example, the monitor subsystem 120 may receive a push notification of the versions of the software and / or hardware layers in the vertical solution stack.

[0034] The server subsystem 104 may include other software processes. For example, the server subsystem 104 may include other background daemons in the vertical solution stack. The server subsystem 104 may include a daemon licensing process 163. The daemon licensing process 163 may communicate with the monitor subsystem 120 and / or the daemon 160 to coordinate the license used by the server subsystem 104. For example, the daemon 160 may coordinate with the daemon licensing process 163 to verify the license on behalf of the client subsystem 110. The monitor subsystem 120 may start the daemon 160 and / or the daemon licensing process 163 and monitor these services as described herein. The server subsystem 104 may also or alternatively include a daemon huge page process 164. The daemon huge page process 164 may communicate with the daemon 160 and / or the huge page control process 166 to manage the huge pages for direct memory access (DMA) transmission between the main memory and external hardware (e.g., external FPGA hardware). For example, the daemon 160 may coordinate with the daemon huge page process 164 on behalf of the client subsystem 110. Monitor subsystem 120 may start daemon process 160 and / or huge page process 164 and monitor these services as described herein. Daemon licensing process 163 and daemon huge page process 164 may be sub-services of monitor subsystem 120 started by monitor subsystem 120.

[0035] The server subsystem 104 may include a loadable kernel driver 162. For example, the loadable kernel driver 162 may be included in a vertical solution stack. The loadable kernel driver 162 may be an application resident in a memory for facilitating interaction between one or more parts of hardware and one or more parts of software. For example, the loadable kernel driver 162 may communicate with a daemon 160 and / or one or more parts of programmable hardware for serving a sequencing system. The loadable kernel driver 162 may support one or more field programmable gate arrays (FPGAs) including a partial reconfiguration bitstream 168. For example, the loadable kernel driver 162 may support one or more FPGAs via a peripheral component interconnect (PCIe) or another type of serial expansion bus for connection to one or more peripheral devices.

[0036] The hardware layer in the server subsystem 104 may include programming for one or more hardware layers in the vertical solution stack, such as an FPGA including a partially reconfigured bitstream 168 and / or a shell 170. The shell 170 may be a hardware layer that includes low-level code for controlling hardware functionality on one or more devices (e.g., server device 102, sequencing device 114, and / or client device 108) on which the server subsystem 104 operates. The FPGA may include higher-level code, such as a partially reconfigurable bitstream 168 for controlling the bioinformatics components of the sequencing system. By uploading different bioinformatics components to the partially reconfigured bitstream 168 of the FPGA by the server subsystem 104, different sequencing features may be used to service requests for the sequencing system. For example, different images of the partially reconfigured bitstream 168 may be uploaded for performing different forms of secondary and / or tertiary forms of sequencing analysis. By uploading different versions of the bioinformatics components via the partially reconfigured bitstream 168 of the FPGA by the server subsystem 104, different sequencing features may be used to service requests for the sequencing system. Different sequencing features may include different algorithms and / or optimization improvements relative to other versions. Each server subsystem 104 may include one or more FPGAs that may each be independently partially reconfigured with custom hardware and / or its own enclosure 170 for board management.

[0037] Figure 1C 1 shows an example of one or more bioinformatics subsystems that may be implemented by a sequencing system operating on server subsystem 104 for performing secondary and / or tertiary forms of sequencing analysis. Figure 1CAs shown, the sequencing system can implement a mapper subsystem 122, a sorter subsystem 124, and / or a variant detector subsystem 126. Each bioinformatics subsystem can perform different sequencing tasks. The mapper subsystem 122 can be implemented to compare the reads in the sequencing data received from the sequencing device 114 and / or stored at one or more devices (e.g., server device 102, sequencing device 114, and / or client device 108) on which the server subsystem 104 operates. The reads in the sequencing data generated and / or generated by the sequencing device 114 and stored in the file in the memory

[0038] The DNA sequence may not be included in a single sequence with all DNA information. Instead, the sequencing data generated by the sequencing device 114 and / or in a file stored in the memory may include multiple short subsequences or reads with partial DNA information. Read alignment may be performed by the mapper subsystem 122 to map the reads to the reference genome and identify the position of each individual read on the reference genome.

[0039] After read alignment is performed at the mapper subsystem 122, the aligned sequencing data can be passed downstream to the sorting subsystem 124 to sort the reads by reference position, and polymerase chain reaction (PCR) or optical duplicates are optionally marked. The initial sorting stage can be performed by the sorter subsystem 124 on the aligned reads returned from the RAM 125. When mapping is complete, final sorting and duplicate marking can begin.

[0040] The variant caller subsystem 126 can be used to call variants from the aligned and sorted reads in the sequencing data. For example, the variant caller subsystem can receive a sorted BAM file as input and process the reads to generate variant information to be included in a variant call file (VCF) or a genomic variant call format (gVCF) file as output from the variant caller subsystem 126.

[0041] For each of the subsystems (e.g., mapper subsystem 122, sorter subsystem 124, and variant caller subsystem 126), a different image may be loaded from disk 123 on server device 102 into random access memory (RAM) 125. For example, RAM 125 may include field programmable gate array (FPGA) board dynamic RAM (DRAM) on server device 102, where different images are loaded from disk 123 for performing different types of analysis using the corresponding subsystem.

[0042] Depending on the different versions of the server subsystem 104 that process the requests from the client subsystems 110a, 110b, different versions of the subsystem may be loaded into the RAM 125 to support the bioinformatics analysis. Figure 1B , different versions of each subsystem can be loaded onto the FPGA as a partial reconfiguration bitstream 168 to enable the server subsystem 104 to perform analysis based on different bioinformatics subsystems (e.g., the mapper subsystem 122, the sorter subsystem 124, and the variant detector subsystem 126).

[0043] like Figure 1B As shown, the daemon 160 may receive requests from authorized client subsystems 110a, 110b and communicate with other daemons 163, 164 and / or a loadable kernel driver 162 to update a partial reconfiguration bitstream 168 to perform sequencing analysis in response to the request. The request may be authorized by the monitor subsystem 120 when the monitor subsystem 120 determines that the request is being received from a client subsystem 110a operating a sequencing application having a version compatible with the current version of the server subsystem 104. The version of the server subsystem 104 may be updated by updating the version of one or more components of the server subsystem 104. For example, the version of the server subsystem 104 may be updated by updating one or more layers of a vertical solution stack, which may include the daemon 160, the daemon licensing process 163, the daemon 164, the huge page control process 166, the loadable kernel driver 162, the partial reconfiguration bitstream 168, and / or the shell 170.

[0044] The monitor subsystem 120 may send commands to the daemon 160 to cause one or more processes, drivers, and / or layers to start, stop, and / or restart. The monitor subsystem 120 may send commands to the daemon 160 to cause the daemon 160 to select and load a version of the sequencing system into memory for operation on the server subsystem 104. The monitor subsystem 120 may send commands to the daemon 160 to load a version of the loadable kernel driver 162 and / or to load a version of the huge page control process 166.

[0045] The monitor subsystem 120 may be responsible for authorizing the client subsystems 110a, 110b to send requests 154, 156 to the daemon 160. When the server subsystem 104 is implementing a version of the sequencing system that is compatible with the version of the sequencing application executed on the client subsystem 110a, 110b from which the request 150, 152 is received, the monitor subsystem 120 may authorize the client subsystems 110a, 110b to send requests 154, 156 to the daemon 160. The request 150, 152 may be triggered by a check from higher-level software, which may provide a complete path or a standard script that may determine the path based on the version number of the sequencing application. The trigger may cause the request 150, 152 to be sent to the monitor subsystem 120 to request permission to continue running. The request 150, 152 may be a blocking check returned when permission is obtained or denied. Requests 150, 152 may each include a product identifier, version identifier, and / or other information associated with the respective client subsystem 110a, 110b from which the requests 150, 152 were received. Monitor subsystem 120 may determine from the information in requests 150, 152 whether client subsystem 110a, 110b is authorized to access daemon 160.

[0046] In one example, the client subsystem 110a and the client subsystem 110b may be operating with different versions of a sequencing application. The monitor subsystem 120 may receive a request 150 from the client subsystem 110a and determine that the client subsystem 110a is operating a sequencing application with a version compatible with the current version of the sequencing system operating on the server subsystem 104. The monitor subsystem 120 may authorize the client subsystem 110a to send a request 154 to the daemon 160 for access to the daemon 160 and / or to have the request serviced by the server subsystem 104. If the monitor subsystem 120 determines that the version of the client subsystem 110a from which the request 150 is received is compatible with the version of the server subsystem 104, the monitor subsystem 120 may send an authorization message 151 to the client subsystem 110a to grant access to the server subsystem 104 and / or the daemon 160. The authorization message may include an acknowledgement in response to the request, or the monitor subsystem 120 may send an acknowledgement of receipt of each request without providing authorization. The authorized client subsystem 110a may be registered with the monitor subsystem 120 in memory as being authorized to be served by the server subsystem 104. The authorization message 151 may include an access key for accessing the server subsystem 104 and / or the daemon 160. The access key may also be provided to the daemon 160 in a notification message that notifies the daemon that the client subsystem 110a has been authorized so that the daemon 160 may identify the authorized client subsystem 110a. As another example, the monitor subsystem 120 may provide the daemon 160 with an identifier of the client subsystem 110a or other information associated with the client subsystem 110a to indicate that the client subsystem 110a has been authorized. The daemon 160 may receive the request 154 and identify that the request is received from the authorized client subsystem 110a (e.g., based on the access key or other information in the request 154). After the daemon 160 recognizes that the request 154 is being received from the authorized client subsystem 110a, the daemon 160 may establish a connection with the client subsystem 110a, register the client subsystem 110a in memory, and begin servicing the request 154 by communicating with other processes, drivers, and / or layers of the vertical solution stack in the server subsystem 104. The connection may be established through a standard Berkeley (BSD) socket or another communication interface, address (e.g., IP address and port), or another communication interface accessible via function calls as an endpoint for sending and / or receiving information.

[0047] Daemon 160 can communicate with loadable kernel driver 162 to serve one or more requests from client subsystem. For example, loadable kernel driver 162 can have one or more FPGA under its control. Loadable kernel driver 162 can support one or more FPGA through PCIe. Bioinformatics subsystem (for example, mapper subsystem 122, sorter subsystem 124 and variant detector subsystem 126) can be loaded into each FPGA for processing request. Different bioinformatics subsystems can be loaded into different FPGAs to process different requests at the same time. In this way, parallel processing across multiple FPGAs can be used to process requests in batches. Each bioinformatics subsystem can operate with a version compatible with the version of the request from the client subsystem. After receiving the corresponding request, workload management and client operations can be assigned to FPGA by daemon 160. Loadable kernel driver 162 can enumerate these devices and provide a communication path between daemon 160 and appropriate FPGA.

[0048] Monitor subsystem 120 may receive request 152 from client subsystem 110b and determine that client subsystem 110b is operating a version of a sequencing application that is incompatible with a current version of a sequencing system operating on server subsystem 104. Because client subsystem 110b is operating a version of a sequencing application that is incompatible with the current version of server subsystem 104, client subsystem 110b may be blocked and / or request 152 may be queued for later service. Requests that are compatible with different versions of the currently loaded server subsystem may be queued in different queues or the same queue. Client subsystem 110b may be blocked and / or request 152 may be queued until the sequencing system of server subsystem 104 is operating a version that is compatible with the version of the sequencing application operating on client subsystem 110b. The monitor subsystem 120 may be unable to provide the access key to the client subsystem 110 b, thereby preventing the client subsystem 110 b from being able to access the daemon 160 of the server subsystem 104, until the server subsystem 104 is operating a version that is compatible with the version of the sequencing application operating on the client subsystem 110 b. The monitor subsystem 120 may send a message to the client subsystem that is configured to cause the client subsystem to wait for authorization and / or transmit a subsequent request at a later time.

[0049] The monitor subsystem 120 may monitor the status of the server subsystem 104 to determine an appropriate time to authorize the client subsystem 110b to access the server subsystem 104. For example, the monitor subsystem 120 may monitor the status of a client subsystem (such as the client subsystem 110a) that has been authorized to access the server subsystem 104 and / or has been registered in memory as authorized. The monitor subsystem 120 may monitor the status of one or more subprocesses (e.g., the daemon process 160, the daemon process permission process 163, and / or the daemon process 164) that are processing requests from client subsystems that have been authorized to access the server subsystem 104, and identify termination signals from one or more subprocesses that are servicing requests from the client subsystems. The termination signal may identify the completion of a service being requested from the server subsystem 104 (e.g., the completion of a service and / or task identified in the request 154) or an abnormal termination that a service being requested failed to complete. If any subprocess has terminated without the monitor subsystem 120 explicitly notifying the subprocess to be stopped by sending a signal, the monitor subsystem 120 is notified by another service that the subprocess has terminated. For example, the monitor subsystem 120 can receive PID (process identifier) ​​and termination reasons from other services operating on the same device. The monitor subsystem 120 can record the PID and / or the reason for termination and restart the process. If the monitor subsystem 120 identifies an abnormal termination, the monitor subsystem 120 can automatically reset the software and / or hardware managed by the server subsystem 104. For example, the monitor subsystem 120 can send a signal to the daemon process 160 so that the daemon process 160 resets the hardware, the subprocesses of the monitor subsystem 120, the processes, the drivers and / or other software in the vertical solution stack. The hardware and / or software can be restarted, and the hardware and / or software can be restarted to operate with the same version of the software loaded into the server subsystem 104 before the restart. After the hardware and / or software has been restarted, the server subsystem 104 can continue to serve requests compatible with the current version of the server subsystem 104.

[0050] When one or more processes in the server subsystem 104 are servicing requests from authorized client subsystems (such as client subsystem 110a), the server subsystem may operate in an active state. When the server subsystem 104 is in an active state and is servicing a request 154 from the client subsystem 110a, the monitor subsystem 120 may continue to receive requests from other client subsystems. Requests from client subsystems that are operating a sequencing application with a version incompatible with the server subsystem 104 may continue to be blocked and / or queued for later service. Requests from client subsystems that are operating a sequencing application with a version compatible with the server subsystem 104 may continue to be authorized (e.g., while requests 152 from client subsystem 110b are queued), and the server subsystem 104 may remain in an active state until a termination signal is identified. When the active state of each client subsystem in the previously authorized client subsystems has terminated, the server subsystem 104 and / or one or more processes therein may enter an idle state.

[0051] The monitor subsystem 120 may communicate with one or more processes of the server subsystem 104 to determine whether the server subsystem 104 and / or one or more processes therein are in an active state or an idle state. In one example, the monitor subsystem 120 may communicate with the daemon process 160 to determine the active state and the idle state of the server subsystem 104 and / or one or more processes therein. The monitor subsystem 120 may send a command to the daemon process 160 to request the current state of the processing of each request from the client subsystem. The monitor subsystem 120 may send a command to the daemon process 160 to query the current version of the server subsystem 104.

[0052] The monitor subsystem 120 may determine from the daemon process 160 when the daemon process 160 and / or other processes or layers in the vertical solution stack are active or idle. When the monitor subsystem 120 determines from the daemon process 160 that the daemon process 160 and / or other processes or layers in the vertical solution stack have stopped serving the client subsystem and entered an idle state for a period of time, the monitor subsystem 120 may change the version of the sequencing system being operated by the server subsystem 104 and authorize a request from the client subsystem operating the sequencing application according to a compatible version.

[0053] The monitor subsystem 120 may select a next version of the sequencing system. In response to user input from the client device 108, the monitor subsystem 120 may select a next version of the sequencing system. The user input may identify the selected version of the server subsystem. The user input may be sent in response to a query from the monitor subsystem 120. The monitor subsystem 120 may automatically select the next version based on the version in the request previously received from the client subsystem. The monitor subsystem 120 may select a version based on the version that was blocked and / or queued in the first request. For example, the monitor subsystem 120 may select a version of the server subsystem 104 to be loaded into memory that is compatible with the version identified in the request 152 received from the client subsystem 110b, which was previously determined to be incompatible. The monitor subsystem 120 may continue to select versions based on the order of requests that have been blocked and / or queued. The monitor subsystem 120 may select a version based on the number of requests that have been blocked and / or queued. For example, monitor subsystem 120 may select the next version to be loaded into memory of server subsystem 104 by identifying a version that is compatible with the greatest number of blocked or queued requests from client subsystems.

[0054] The monitor subsystem 120 can communicate with one or more processes of the server subsystem 104 to coordinate the change of the version of the sequencing system operating on the server subsystem 104. In one example, the monitor subsystem 120 can communicate with the daemon process 160 to restart one or more parts of the hardware and / or software to change the version of the server subsystem 104. One or more layers (e.g., each layer) of the vertical solution stack of the server subsystem 104 can be removed and rebuilt for the next version. The monitor subsystem 120 can send a command to the daemon process 160 so that the daemon process deletes one or more processes, drivers and / or layers currently loaded into the memory. The command from the monitor subsystem 120 can be received by one or more subprocesses (e.g., daemon process 160) so that one or more layers remove the current version service by shutting down the service supporting the current version before switching to another version. The monitor subsystem 120 can send a command received by one or more subprocesses (e.g., daemon process 160) so that one or more layers are rebuilt to support the next version by restarting the next version of the service. For example, the monitor subsystem 120 may send one or more commands to one or more subprocesses (e.g., daemon process 160) that communicate with one or more other layers of the vertical solution stack to tear down and rebuild the services supported by each layer. One or more subprocesses (e.g., daemon process 160) may reset the FPGA and / or load new programmable hardware into the FPGA to implement a complete solution including version changes in hardware and / or software.

[0055] The processes, drivers and / or layers to be removed and / or rebuilt when changing versions can be predefined or can be dynamically selected. For example, the monitor subsystem 120 can select the processes, drivers and / or layers to be removed and / or rebuilt based on the previous version and the next version of the server subsystem 104. Each version of the sequencing system can be stored in the memory together with the version file, which can be accessed by the monitor subsystem 120 to identify the part of the next version of the sequencing system to be disassembled and / or built to support the operation of the server subsystem 104. Each version of the sequencing system can include metadata or other information that can be read by the monitor subsystem for selecting the processes, drivers and / or layers of the vertical solution stack for loading into the memory. For example, each version of the sequencing system can provide a list, and the monitor subsystem 120 can use the list to select the processes, drivers and / or layers to be loaded into the memory for each version. Each list can include a version number corresponding to the version of the sequencing system for which the list is provided. The list can include the list version itself, because each list can have different versions. The manifest may include a version of one or more processes and / or drivers for loading into the memory to build a vertical solution stack. For example, the manifest may include a version of the daemon process 160 for supporting the version of the server subsystem 104, a version of the daemon process license process 163, and / or a version of the daemon process huge page process 164. The manifest may include a driver version for a loadable kernel driver 162 and / or the location of a kernel object. For example, the location of a kernel object may include a version directory or an alternative location (for example, when supporting multiple versions of a kernel driver). The manifest may include a version of a client subsystem compatible with the version of the server subsystem 104 and / or a sequencing application program operated thereon. The manifest may include a version of a partially reconfigured bitstream 168 and / or a subsystem (for example, a mapper subsystem 122, a sorter subsystem 124, and / or a variant detector subsystem 126) that may be loaded therein. The manifest may include a version of a shell 170. Some processes, drivers, and / or layers may remain static from one version to another, which may support backward compatibility with traditional systems. For example, the loadable kernel driver 162 and / or the shell 170 may remain static between versions to support processes in other layers of the vertical solution stack.

[0056] After the monitor subsystem 120 selects the version of the sequencing system being operated by the server subsystem 104 and loads the processes, drivers, and / or layers of the selected version of the sequencing system, processes may be started and / or drivers may be loaded into the vertical solution stack to service requests compatible with the selected version of the sequencing system. In one example, when the monitor subsystem 120 determines that the version of the sequencing system running on the server subsystem 104 is compatible with the version of the sequencing application of the client subsystem 110b, the monitor subsystem 120 may authorize the client subsystem 110b to access the server subsystem 104 and / or one or more processes thereon. The monitor subsystem 120 may authorize the client subsystem 110b to send a request 156 to the daemon process 160 for accessing the daemon process 160 and / or having the request serviced by the server subsystem 104. After the monitor subsystem 120 determines that the version of the client subsystem 110b from which the request 152 is received is compatible with the version of the server subsystem 104, the monitor subsystem 120 may send an authorization message 153 to the client subsystem 110b to grant access to the server subsystem 104 and / or the daemon 160. The authorization message may include an acknowledgement in response to the request, or the monitor subsystem 120 may send an acknowledgement of receipt of each request without providing authorization. The authorized client subsystem 110b may be registered with the monitor subsystem 120 in a memory as being authorized to be served by the server subsystem 104. The authorization message 153 may include an access key for accessing the server subsystem 104 and / or the daemon 160. The access key may also be provided to the daemon 160 in a notification message that notifies the daemon that the client subsystem 110b has been authorized so that the daemon 160 can identify the authorized client subsystem 110b. As another example, the monitor subsystem 120 may provide the daemon 160 with an identifier of the client subsystem 110b or other information associated with the client subsystem 110b to indicate that the client subsystem 110b has been authorized. The daemon 160 may receive the request 156 and identify that the request is received from the authorized client subsystem 110b (e.g., based on an access key or other information in the request 156). After the daemon 160 identifies that the request 156 is being received from the authorized client subsystem 110b, the daemon 160 may establish a connection with the client subsystem 110b, register the client subsystem 110b in a memory, and begin servicing the request 156 by communicating with other processes, drivers, and / or layers of the vertical solution stack in the server subsystem 104. For example, the daemon 160 may communicate with its clients using an inter-process communication (IPC) messaging protocol on a BSD socket. Each client may register with the daemon 160 by connecting to a Unix domain socket address.The channel may be open for the client to send a message to the daemon 160, to which the daemon 160 may respond after completing the client's request.

[0057] Figure 2 200 is a flowchart depicting an exemplary process 200 for monitoring the version of a server subsystem and processing a request from a compatible client subsystem. One or more parts of process 200 may be performed by one or more computing devices or systems. For example, one or more parts of process 200 may be performed by one or more server devices, one or more sequencing devices, and / or one or more client devices. One or more parts of process 200 may be stored in a memory as computer-readable or machine-readable instructions that may be performed by a processor of one or more computing devices. One or more parts of process 200 may be performed by one or more subsystems operating on a client device, a sequencing device, and / or a server device. For example, one or more parts of the process may be performed by a client subsystem, a server subsystem, and / or a monitor subsystem, as described herein. Although parts of process 200 may be described herein as being performed by a monitor subsystem, process 300 or parts thereof may be performed by another subsystem operating on a computing device or distributed across multiple computing devices (such as one or more client computing devices, one or more sequencing devices, and / or one or more server computing devices).

[0058] Process 200 may begin at 202. Figure 2As shown, at 202, the monitor subsystem may receive one or more requests from one or more client subsystems. These requests may be received individually or in batches so as to be processed by the sequencing system of the server subsystem. The request may include a product identifier, a version identifier, and / or other information associated with the client subsystem from which the request is received. At 204, the monitor subsystem may determine the version associated with the client subsystem from which the request is received. For example, the monitor subsystem may determine the version based on the product identifier, the version identifier, or other information associated with the client subsystem. At 206, the monitor subsystem may determine whether the version associated with the server subsystem is compatible with the version associated with the client subsystem. For example, the monitor subsystem may receive an indication of the version of the sequencing system operating on the server subsystem to determine whether the version of the sequencing system is compatible with the version of the sequencing application operating on the client subsystem. An indication of the version of the sequencing system operating on the server subsystem may be received from a daemon operating on the server subsystem (e.g., in response to a request). Compatible versions can be indicated by the same version number / identifier, or by different version numbers / identifiers indicated in memory as compatible with one or more features of another version number / identifier. Versions can be versions of one or more processes, drivers, and / or layers of a vertical solution stack. If the version associated with the server subsystem is compatible with the version associated with the client subsystem, then at 210, the client subsystem may be granted access to the server subsystem and / or one or more processes thereon for processing the request. The request can be processed by loading one or more bioinformatics subsystems (e.g., a mapper subsystem, a sorter subsystem, and / or a variant detector subsystem) into one or more FPGAs for performing secondary and / or tertiary analysis of sequencing data.

[0059] If the version associated with the server subsystem and the version associated with the client subsystem are incompatible, then at 208, the monitor subsystem may cause the client subsystem to wait for the request to be processed. For example, the monitor subsystem may block the request to prevent access to the server subsystem and / or queue the request for later processing. At 212, the monitor subsystem may determine whether additional requests have been received while the server subsystem is operating its sequencing system with the current version. For example, while the server subsystem is processing one or more requests from a client subsystem that has been granted access at 210 and / or before the server subsystem has changed versions, additional requests may continue to be received by the monitor subsystem. If the monitor subsystem receives an additional request at 212, the request may be processed at 204 to determine the version associated with the client subsystem in order to determine at 210 whether access to the request is granted. At 214, the monitor subsystem may determine whether the server subsystem is idle. The server subsystem may be determined to be idle when one or more processes operating the sequencing system on it are determined to be idle. The monitor subsystem may request the status of one or more processes of the server subsystem. In one example, the monitor subsystem can send a message to the daemon process of the server subsystem to determine the processing status of the request from the client subsystem. The daemon process can send a termination signal at the end of processing the request from one or more client subsystems. The monitor subsystem can monitor the status of the request and identify the termination signal of each previously authorized request. If the server subsystem is determined to be still active and processing a request from the client subsystem, the monitor subsystem can continue to monitor additional requests at 212 and / or monitor the server subsystem at 214 to identify an idle state.

[0060] If the server subsystem and / or one or more processes operating thereon are determined to be idle, then at 215, the monitor subsystem may determine whether to change the version associated with the server subsystem. The monitor subsystem may identify an indication for changing the version associated with the server subsystem before making the change. For example, if an additional request associated with an incompatible version that has been blocked and / or queued has been received from a client subsystem, the monitor subsystem may determine to change the version associated with the server subsystem. The monitor subsystem may also or alternatively determine to change the version associated with the server subsystem if user input has been received from a sequencing application operating on a client device that instructs the monitor subsystem to change the version of the server subsystem. If the monitor subsystem decides to maintain the version associated with the server subsystem (e.g., because no indication to change the version associated with the server subsystem is identified), process 200 may end.

[0061] If the monitor subsystem decides to change the version associated with the server subsystem, then at 216, the monitor subsystem can cause the server subsystem to change the version of the request from the client subsystem compatible with another version of the server subsystem. The monitor subsystem can send a command to the server subsystem and / or one or more processes operating thereon so that the server subsystem stops executing one or more processes before changing the version. The monitor subsystem can send a command to the server subsystem and / or one or more processes operating thereon so that the server subsystem changes the version for processing the request from the client subsystem. The command can be sent to the daemon operating on the server subsystem so that the version of one or more processes, drivers and / or layers of the vertical solution stack changes according to the next version. The next version can be selected by the monitor subsystem. For example, the next version can be selected based on the user input received from the client device operating the sequencing application. The next version can also or alternatively be automatically selected based on the version of the request previously blocked and / or queued from the client subsystem. The monitor subsystem may select a version based on the blocked and / or queued versions in the first request or the order of the requests that have been blocked and / or queued. The monitor subsystem may select a version based on the number of requests that have been blocked and / or queued. For example, the monitor subsystem may select the next version to be loaded into the memory of the server subsystem by identifying the version that is compatible with the largest number of blocked and / or queued requests from the client subsystem.

[0062] After the version associated with the server subsystem has been changed to the next version, the monitor subsystem may send a command to the server subsystem and / or one or more processes (e.g., daemon) thereon to start execution. At 218, the monitor subsystem may determine whether a previous request that has been blocked and / or queued for processing by the server subsystem has been received. If a previous request for processing by the server subsystem has not yet been received, process 200 may end. If a previous request that has been blocked and / or queued is received, at 204, the monitor subsystem may determine whether the version of one or more previous requests is compatible with the server subsystem. The monitor subsystem may send a message to the client subsystem to notify the client subsystem that the server subsystem is ready to serve its request. The monitor subsystem may send a request, requiring the client subsystem to resend their request for processing. At 210, the monitor subsystem may grant access to process requests associated with the client subsystem that are determined to be compatible. After the current version associated with the server subsystem has been changed, the monitor subsystem may continue to block requests that are incompatible with the current version and / or queue them. After each of the requests has been processed as described herein, the process can end.

[0063] Figure 3 is a block diagram illustrating an exemplary computing device 300 (or computing system). One or more computing devices (such as computing device 300) may implement one or more features for monitoring and / or changing versions of a sequencing system to service requests from a sequencing application, as described herein. For example, computing device 300 may include Figure 1A One or more of the sequencing device 114, the client device 108, and / or the server device 102 shown. Figure 3 As shown, computing device 300 may include processor 302, memory 304, storage device 306, I / O interface 308, and communication interface 310, which may be communicatively coupled via communication infrastructure 312. Computing device 300 may include Figure 3 Fewer or more components than those shown.

[0064] The processor 302 may include hardware for executing instructions, such as those that constitute a computer application or system. In an example, to execute instructions for operating as described herein, the processor 302 may retrieve (or extract) instructions from an internal register, an internal cache, a memory 304, or a storage device 306, and decode and execute the instructions. The memory 304 may be a volatile or non-volatile memory for storing data, metadata, computer-readable or machine-readable instructions, and / or a program executed by the processor to operate as described herein. The storage device 306 may include a storage device for storing data or instructions for performing the methods described herein, such as a hard disk, a flash drive, or other digital storage device.

[0065] The I / O interface 308 may allow a user to provide input to the computing device 300, receive output from the computing device, and / or otherwise transmit data to and receive data from the computing device. The I / O interface 308 may include a mouse, a keypad or keyboard, a touch screen, a camera, an optical scanner, a network interface, a modem, other known I / O devices, or a combination of such I / O interfaces. The I / O interface 308 may include one or more devices for presenting output to a user, including but not limited to a graphics engine, a display (e.g., a display screen), one or more output drivers (e.g., a display driver), one or more audio speakers, and one or more audio drivers. The I / O interface 308 may be configured to provide graphics data to the display for presentation to the user. The graphics data may represent one or more graphical user interfaces and / or any other graphical content.

[0066] The communication interface 310 may include hardware, software, or both. In any case, the communication interface 310 may provide one or more interfaces for communication (such as, for example, packet-based communication) between the computing device 300 and one or more other computing devices and / or networks. The communication may be wired or wireless. As an example and not by way of limitation, the communication interface 310 may include a network interface controller (NIC) or a network adapter for communicating with an Ethernet or other wired-based network, or a wireless NIC (WNIC) or a wireless adapter for communicating with a wireless network such as WI-FI.

[0067] Additionally, the communication interface 310 can facilitate communication with various types of wired or wireless networks. The communication interface 310 can also facilitate communication using various communication protocols. The communication infrastructure 312 can also include hardware, software, or both that couple the components of the computing device 300 to each other. For example, the communication interface 310 can use one or more networks and / or protocols to enable multiple computing devices connected through a particular infrastructure to communicate with each other to perform one or more aspects of the processes described herein. For example, a sequencing process can allow multiple devices (e.g., a client device, a sequencing device, and a server device) to exchange information such as sequencing data and error notifications.

[0068] In addition to what has been described herein, the methods and systems may also be implemented in a computer program, software, or firmware incorporated into one or more computer-readable media for execution by, for example, a computer or processor. Examples of computer-readable media include electronic signals (transmitted via a wired or wireless connection) and transient / non-transient computer-readable storage media. Examples of transient / non-transient computer-readable storage media include, but are not limited to, read-only memory (ROM), random access memory (RAM), removable disks, and optical media such as CD-ROM disks and digital versatile disks (DVDs).

[0069] Although the present disclosure has been described according to certain embodiments and generally associated methods, the changes and permutations of the embodiments and methods will be apparent to those skilled in the art. Therefore, the above description of the exemplary embodiments does not limit the present disclosure. Other changes, substitutions and variations are also possible without departing from the spirit and scope of the present disclosure.

Claims

1. A system, comprising: at least one memory having computer readable instructions stored thereon; and At least one processor, the at least one processor being configured in response to the computer-readable instructions to: receiving, via the monitor subsystem, a request from a client subsystem, wherein the request is a request to perform a secondary analysis or a tertiary analysis of sequencing data, wherein the request includes a version associated with the client subsystem; determining a first version associated with a server subsystem to be implemented to service the request; determining that the version associated with the client subsystem is incompatible with the first version associated with the server subsystem currently implemented to service the request; responsive to the determination that the version associated with the client subsystem and the first version associated with the server subsystem are incompatible, preventing the server subsystem from being accessed by the client subsystem; identifying a change from the first version to a second version associated with the server subsystem; determining that the second version associated with the server subsystem is compatible with the version associated with the client subsystem; as well as The client subsystem is allowed to access the server subsystem to service the request.

2. The system of claim 1, wherein the request from the client subsystem is a first request, and wherein the client subsystem is a first client subsystem, the at least one processor being further configured in response to the computer-readable instructions to: receiving, via the monitor subsystem, a second request from a second client subsystem, wherein the second request includes a version associated with the second client subsystem; determining that the version associated with the second client subsystem is compatible with the first version associated with the server subsystem when the server subsystem is operating at the first version; and The server subsystem is allowed to be accessed by the second client subsystem in response to the second request.

3. The system of claim 1 , wherein the at least one processor is further configured in response to the computer readable instructions to: After processing each request from a client subsystem associated with a compatible version, identifying that the server subsystem is idle; and The server subsystem is caused to perform a change from the first version to the second version.

4. The system of claim 1, wherein each version of the server subsystem includes different features of a bioinformatics component associated with processing different requests for the secondary analysis or the tertiary analysis.

5. The system of claim 1, wherein different bioinformatics components are utilized by loading the different bioinformatics components into one or more field programmable gate arrays (FPGAs). 6 . The system of claim 1 , wherein the change from the first version to the second version comprises tearing down and building up at least one software layer in a vertical solution stack.

7. The system of claim 6, wherein the first version and the second version support loading different bioinformatics components onto one or more FPGAs to support the same or different sequencing tasks.

8. The system according to claim 7, wherein the sequencing task comprises a task performed for the secondary analysis or the tertiary analysis of the sequencing data.

9. The system of claim 1, wherein the secondary analysis or the tertiary analysis comprises alignment, sorting or variant calling based on the sequencing data.

10. The system of claim 1, wherein the monitor subsystem is a daemon process.

11. The system of claim 1 , wherein the server subsystem is a daemon process, and wherein the server subsystem is configured to manage hardware on the system to serve sequencing applications operating on one or more client subsystems.

12. The system of claim 11, wherein the daemon process is one predefined daemon process among a plurality of predefined daemon processes in the server subsystem.

13. The system of claim 1, wherein the at least one processor is configured to prevent the server subsystem from being accessed by the client subsystem in response to the request further comprising the at least one processor being configured to: An access key is prevented from being transmitted to the client subsystem or a connection is prevented from being established between the client subsystem and the server subsystem.

14. The system of claim 1, wherein the at least one processor is configured to allow the server subsystem to be accessed by the second client subsystem further comprising the at least one processor being configured to: providing an access key to the second client subsystem via the monitor subsystem; and The server subsystem is notified via the monitor subsystem that the access key has been provided to the second client subsystem.

15. The system of claim 14, wherein the at least one processor being configured to notify the server subsystem further comprises the at least one processor being configured to provide the access key to the server subsystem.

16. The system of claim 14, wherein the processor is further configured via the computer readable instructions to: receiving, via the first client subsystem, a message indicating that the first client subsystem has been blocked; and Waiting to receive an indication from the monitor subsystem via the first client subsystem indicating that the request can be processed.

17. The system of claim 14, wherein the processor is further configured via the computer readable instructions to: receiving the access key via the second client subsystem; and A message including the access key for establishing a connection with the server subsystem is transmitted to the server subsystem.

18. The system of claim 1, wherein the processor is further configured via the computer-readable instructions to send an acknowledgment to the client subsystem in response to the request.

19. The system of claim 1, wherein the processor is further configured via the computer-readable instructions to receive the request from the client subsystem via a socket and grant access to the server subsystem through the socket via an access key.

20. The system of claim 1, wherein the processor is further configured via the computer readable instructions to: monitoring, by the monitor subsystem, a signal from at least one child process; detecting a terminal signal via the at least one child process; and The at least one child process is automatically restarted.

Citation Information

Patent Citations

  • Compatibility control method for C / S (client / server) structure application program versions

    CN102521001A

  • Managing Different Versions of Server Components Regarding Compatibility With Collaborating Servers

    US20080301668A1

  • Systems and Methods for Versioning Hosted Software

    US20140088880A1

  • Methods for control of a sequencing device

    US20210057090A1

  • System and Method for Control of Sequencing Process

    US20220205033A1