Variant extension of high coverage sample

Abstract

Systems, methods, and apparatus are described herein for identifying detectable regions and performing variable detection upon allocated in-memory operations. The sequencing subsystem may include a variable extractor or a variable extractor subsystem. The variable extractor may include a detection subsystem configured to identify a detectable region and a downstream genotyping subsystem that may send the detectable region to the variable extractor. The detection subsystem of the variable detector may be configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is above a detectable region depth threshold. The checkout subsystem of the variant extractor may monitor memory used by the detectable region, and when the memory used exceeds a memory threshold of the allocated total amount of memory, the checkout subsystem may segment or overflow at least a portion of the detectable region to operate within the allocated total amount of memory.

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims priority to U.S. Provisional Patent Application No. 63 / 355,541, filed on June 24, 2022, the entire text of which is incorporated herein by reference. Background Art

[0003] In recent years, biotechnology companies and research institutions have improved hardware and software platforms to determine the sequence of nucleotide bases (or whole genomes) and identify variant calls of nucleotide bases that are different from the reference bases of the reference genome. Sequencing platforms can monitor tens of thousands or more oligonucleotides to detect more accurate nucleotide base calls from larger base call data sets. For example, cameras in such sequencing platforms can capture images of irradiated fluorescent labels from nucleotide bases incorporated into such oligonucleotides. After capturing such images, the sequencing platform sends the base data to a computing device with sequencing data analysis software, which compares the nucleotide reads to the reference genome. Based on these aligned nucleotide fragment reads, the sequencing platform can determine the nucleotide base calls of the genomic region and identify variants within the sample nucleic acid sequence.

[0004] As the amount of sequencing data that can be analyzed continues to grow, challenges arise when operating a sequencing platform within certain hardware allocations of a computing system that operates the sequencing platform. For example, when loading sequencing data into memory, the size of the sequencing data may exceed certain memory allocations and cause processing delays or crashes of the sequencing platform and / or other applications executed on the computing system. The sequencing platform may need to operate within such allocations and continue to grow to cope with the increase in sequencing data to be analyzed. Summary of the invention

[0005] Described herein are systems, methods, and devices for identifying detectable regions and performing variant detection while operating within an allocated memory. A sequencing subsystem may include a secondary analysis subsystem implemented on one or more devices to perform secondary analysis of sequencing data. For example, a sequencing subsystem may include a variant detector or a variant detector subsystem. The variant detector may include a detection subsystem that is configured to identify a detectable region for being processed to perform variant detection and / or base detection. The detection subsystem may send the detectable region to a downstream genotyping subsystem of the variant detector. The genotyping subsystem may perform variant detection and / or base detection within the detectable region.

[0006] The detection subsystem of the variant detector can receive sequencing data including multiple reads of the genomic sequence. The detection subsystem of the variant detector can be configured to detect the detectable area of ​​the sequencing data when the depth of the multiple reads is higher than the detectable area depth threshold. The detection subsystem of the variant detector can monitor its memory usage. The memory threshold can be a fixed threshold or a dynamic threshold. When the memory used by the detection subsystem of the variant detector exceeds the memory threshold of the total amount of memory allocated to the detection subsystem, the detection subsystem can segment the detectable area, and send the segmented part of the detectable area to the genotyping subsystem of the variant detector to perform variant detection based on the segmented part. Sending the segmented part of the detectable area to the genotyping subsystem increases the availability of the memory used by the detection subsystem.

[0007] When the memory used by the detection subsystem of the variant detector is within the memory threshold of the total amount of memory allocated to the detection subsystem of the variant detector, the detection subsystem can analyze the sequencing data to identify insertions, deletions, or other variants or mutations in the sequencing data within the predetermined proximity of the identified segmentation. After identifying the variants or mutations in the sequencing data, the detection subsystem can segment the detectable region outside the predetermined proximity of the variant or mutation. The identified segmented variants or mutations and / or the predetermined proximity can be determined based on the population data accessed by the detection subsystem.

[0008] The detection subsystem may analyze the buffered sequencing data to identify the location of the segmentation of the detectable region within the buffered sequencing data. The detection subsystem may identify a portion of the buffered sequencing data having a read depth below the segmentation threshold, and perform segmentation of the buffered sequencing data at the identified portion having a read depth below the segmentation threshold. The segmented portion of the detectable region may be the entirety of the detectable region currently in the memory used by the detection subsystem. In another example, the detection subsystem may maintain a predetermined amount of sequencing data in a first segmented portion of the detectable region in a memory used by the detection subsystem of the variant detector, so that the first segmented portion and the second segmented portion of the detectable region have an overlap in the sequencing data. The overlap may include a predetermined number of bases. The overlap may be determined based on population data or user input accessed by the detection subsystem. The genotyping subsystem may remove the overlap in the sequencing data between the segmented portions of the detectable region before performing variant calling on the detectable region.

[0009] In another exemplary embodiment, when the memory used by the detection subsystem of the variant caller is within the memory threshold of the total amount of memory allocated to the detection subsystem of the variant caller, the detection subsystem may overflow the detectable area to disk storage. The overflowed detectable area can then be streamed from the disk back to the memory used for processing by the genotyping subsystem. The entire detectable area can overflow to the disk, or a portion of the detectable area can overflow to the disk, and a second portion of the detectable area can be maintained in the memory. The genotyping subsystem can analyze the overflowed detectable area streamed back from the disk, and before streaming additional portions of the overflowed detectable area to the memory, discard one or more portions of the overflowed detectable area that will not be used for variant calling from the memory. The genotyping subsystem can have a separate allocation of memory, and a second memory threshold associated with the genotyping subsystem can be monitored to prevent the second memory threshold from being exceeded when the overflowed detectable area is streamed from the disk. BRIEF DESCRIPTION OF THE DRAWINGS

[0010] Figure 1A A schematic diagram illustrating the system environment.

[0011] Figure 1B Examples of one or more subsystems that may be implemented by a sequencing subsystem for identifying variants or base calls are shown.

[0012] FIG. 2A to FIG. 2E Included are diagrams illustrating examples for segmenting detectable regions into genomic regions.

[0013] Figure 3 is a flow chart of a process for segmenting detectable regions into genomic regions based on a memory threshold.

[0014] Figure 4 is a flow chart of a process for spilling a checkout area to disk based on a memory threshold.

[0015] Figure 5 is a block diagram of an exemplary computing device. DETAILED DESCRIPTION

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

[0017] like Figure 1AAs 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 example 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 WIFI communication protocol, and / or another wireless communication protocol). As an additional or alternative to 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.

[0018] like Figure 1A As shown, the sequencing device 114 may include a device for sequencing a biological sample. The biological sample may include human and non-human deoxyribonucleic acid (DNA) to determine the single nucleotide bases of the nucleic acid sequence (e.g., synthetic sequencing). The biological sample may include human and non-human ribonucleic acid (RNA). The sequencing device 114 may analyze the 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 the nucleic acid fragments into nucleotide reads.

[0019] like Figure 1A As further shown, the server device 102 can generate, receive, analyze, store and / or transmit electronic 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 data for analysis by the server device 102 for base calling and variant calling. The server device 102 can also communicate with the client device 108. In particular, 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 a user via the client device 108.

[0020] 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.

[0021] like Figure 1AAs further shown, the server device 102 and / or the sequencing device 114 may include a sequencing subsystem 104. The sequencing subsystem 104 may be implemented as hardware and / or software on one or more devices to perform secondary analysis of sequencing data. The sequencing subsystem may be implemented as a secondary analysis subsystem on one or more devices to perform secondary analysis. For example, the sequencing subsystem 104 may analyze nucleotide reads and / or other data received from the sequencing device 114, such as sequencing metrics, to determine the nucleotide base sequence of nucleic acid polymers. For example, the sequencing subsystem 104 may receive the raw data from the sequencing device 114 and may determine the nucleotide base sequence of nucleic acid fragments. The raw data may be able to be identified to be received from the sequencing device 114 in a file format (such as a FASTQ file) for processing. The FASTQ file may include a text file that contains sequence data from a cluster passing through a filter on a circulation cell. The FASTQ format is a text-based format for storing biological sequences (e.g., such as nucleotide sequences) and their corresponding quality scores. The sequencing subsystem 104 may process the sequencing data to determine the sequence of nucleotide bases in the DNA and / or RNA fragments or oligonucleotides.

[0022] In addition to processing and determining the sequence of the biological sample, the sequencing subsystem 104 can also generate files for processing and / or transferring to other devices. The generated files can be sequence alignment / mapping (SAM) format, binary alignment / mapping (BAM) format, compressed reference-oriented alignment mapping (CRAM) format and / or another file format for processing and / or transferring to other devices. The SAM format can be an alignment format for storing reads aligned with a reference genome. The SAM format can support short reads and long reads (e.g., up to 128Mb) produced by different sequencing devices 114. The SAM format can be a human-readable text format file. The BAM format can maintain the same information in the SAM file, but maintain it in a machine-readable compressed binary format. The BAM file can show the alignment of the reads received in the data received from the sequencing device 114. The CRAM file can be stored in a compressed columnar file format for storing biological sequences.

[0023] The 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 including 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.

[0024] Figure 1AThe client device 108 shown 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.

[0025] like Figure 1A As further shown, the client device 108 may include a sequencing application 110. The sequencing application 110 may be a web application or a native application (e.g., a mobile application, a desktop application) stored and executed on the client device 108. The sequencing application 110 may include instructions that, when executed, cause the client device 108 to receive data from a sequencing device 114 and present the data for display at the client device 108 to a user of the client device 108, such as data from a variant call file.

[0026] like Figure 1A As further shown, the environment 100 may include a database 116. The database 116 may store information such as variant call files, sample nucleotide sequences, nucleotide reads, nucleotide base calls, sequencing metrics, population data, and / or other data as described herein. The server device 102, the client device 108, and / or the sequencing device 114 may communicate with the database 116 (e.g., via the network 112) to store and / or access information such as variant call files, sample nucleotide sequences, nucleotide reads, nucleotide base calls, sequencing metrics, population data, and / or other data as described herein.

[0027] Environment 100 may be included in a local network or local high performance computing (HPC) system. Environment 100 may be included in a cloud computing environment including multiple server devices, such as server device 102, on which software and / or data are distributed. Sequencing subsystem 104 may be implemented to operate one or more subsystems as described herein, and may be implemented on a single device (such as server device 102 or sequencing device 114), or distributed across multiple devices (such as server device 102 and / or sequencing device 114). For example, server device 102 and / or sequencing device 114 may access database 116 via network 112 in a cloud-based computing system.

[0028] although Figure 1A The components of environment 100 are illustrated as communicating via network 112, but it should be understood that the components of environment 100 may communicate directly with each other, for example, bypassing network 112. For example, client device 108 may communicate directly with sequencing device 114.

[0029] The sequencing subsystem 104 may include one or more sequencing subsystems for analyzing the sequencing data received from the sequencing device 114 and / or for performing secondary analysis to identify variants in the sequencing data. Nucleotide base calls may indicate the determination or prediction of the type of nucleotide bases incorporated into the oligonucleotides on the nucleotide sample slide (e.g., nucleotide base calls based on reads), or the determination or prediction of the type of nucleotide bases present at the genomic coordinates or genomic regions in the sample genome. For example, nucleotide base calls may include base calls corresponding to genomic coordinates and a reference genome, such as an indication of a variant or non-variant at a specific position corresponding to the reference genome. Nucleotide base calls may refer to a base detected at a position in a read and a quality score indicating the confidence of the call. Base calls may allow for the detection of mutations or variants based on comparisons between base calls in each read spanning a certain position and bases occurring at the same position in the reference genome. Variants may include, but are not limited to, single nucleotide polymorphisms (SNPs), insertions or deletions (indels), or base calls as part of structural variants. Insertions change a DNA sequence by adding one or more nucleotides to the sequence compared to a reference genome. Deletions change a DNA sequence by removing at least one nucleotide from the sequence compared to a reference genome. The deleted DNA may alter the function of one or more affected proteins. Single nucleotide base calls may include adenine calls, cytosine calls, guanine calls, or thymine calls (abbreviated A, C, G, T) for DNA or uracil calls (instead of thymine calls) (abbreviated U) for RNA. Mutations may include a single change or difference in a gene sequence. Variants may include sequences comprising one or more mutations.

[0030] Figure 1B 2 shows an example of one or more subsystems that may be implemented by sequencing subsystem 104 to identify variants. Figure 1BAs shown, sequencing subsystem 104 may implement mapper subsystem 122, sorter subsystem 124 and / or variant detector subsystem 126. The one or more subsystems may be implemented to perform secondary analysis. Mapper subsystem 122 may be implemented to compare reads in sequencing data received from sequencing device 114 and / or stored at server device 102. Reads in sequencing data generated by sequencing device 114 and / or generated and stored in files by server device 102 may not be included in a single sequence with all DNA information. On the contrary, sequencing data generated by sequencing device 114 and / or generated in files by server device 102 may include multiple short subsequences or reads with partial DNA information. Read comparison may be performed by mapper subsystem 122 to map reads to a reference genome and identify the position of each individual read on the reference genome. The mapper subsystem 122 can flow unaligned reads from sequencing data as FASTQ or ILLUMINA single base call (BCL) files and perform read alignment on the sequencing data therein. FASTQ files can contain up to millions of entries and can be several megabytes (Mb) or gigabytes (GB) in size. The mapper subsystem 122 can output aligned reads in aligned BAM files, as described herein.

[0031] BAM files may include header segments and comparison segments. The header segment may include information about the file, such as sample name, sample length, and comparison method. The comparison segment may include read segment name, read segment sequence, read segment quality, comparison information, and other custom tags for read segments. For each read segment or read segment pair, the comparison segment may include a read segment group. The read segment group may include a subset of read segments prepared from the same lane, sample, and / or library on the flow cell. Different read segment groups may have different coverages or different depths. The depth may be determined by the number of read segments aligned to a certain position in the sequence with a certain quality. The depth may be determined by the number of read segments aligned to a certain position in the sequence with a certain quality. The number of read segments may be determined for one or more read segment groups. The comparison segment may include a barcode label indicating a demultiplexed sample identifier associated with the read segment. The comparison segment may include a single-end comparison quality. The comparison segment may include an edit distance label that records the Levenshtein distance (Levenshtein distance) between the read segment and the reference.

[0032] Hash tables can be used to perform read alignment. Hash tables can be established for genome reference, which can enable sub-portions or seeds of reads to be mapped to genomes. The position of the read can be determined according to the result of the seed extension at each mapping position. The mapper subsystem 122 can use the hash table index of the reference genome to map many overlapping seeds from each read to the exact match in the reference. The hash table can be constructed from any selected reference by a multithreaded tool and loaded into a random access memory (RAM) 125. For example, RAM 125 may include a field programmable gate array (FPGA) board dynamic RAM (DRAM) on server device 102. The hash table can be stored on RAM 125 before the mapper subsystem 122 performs a mapping operation. The read mapping method can be performed by the FPGA logic on RAM 125.

[0033] After performing read alignment at the mapper subsystem 122, the aligned sequencing data can be passed downstream to the sorter subsystem 124 to sort the reads by reference position, and optionally to polymerase chain reaction (PCR) or optical replicas. The initial sorting phase can be performed by the sorter subsystem 124 on the aligned reads returned from the RAM 125. When the mapping is complete, the final sorting and replica marking can begin. The sorter subsystem 124 can write another BAM file including the sorted sequencing data to the RAM 125 for downstream access by the variant detector subsystem 126.

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

[0035] The variant detector subsystem 126 may include a detection subsystem 128 and / or a genotyping subsystem 130. When the variant detector subsystem 126 receives sequencing data, the detection subsystem 128 may identify a detectable region with sufficient alignment coverage. The detectable region may be identified based on the read depth. The read depth may represent the number of times a specific base is expressed in each read in the sequencing data. Sometimes the wrong base may be incorporated into the DNA fragment identified in the sequencing data. For example, the camera in the sequencing device 114 may pick up the wrong signal, the mapper subsystem 122 may misplace the read, or the sample may be contaminated and cause an incorrect base to be detected in the sequencing data. By sequencing each fragment multiple times to produce multiple reads, there is a certain degree of confidence or possibility that the identified variant is a true variant rather than an illusion from the sequencing method. The read depth represents the number of times each individual base has been sequenced, or the number of reads in which a single base appears in the sequencing data. The higher the read depth, the higher the confidence level of the variant call.

[0036] The detectable region can be a region that is passed downstream to the genotyping subsystem 130 for detecting variants from the detectable region. For example, the genotyping subsystem 130 can compare the detectable region with the reference genome for variant detection. When the read depth of the sequencing data is higher than the detectable region depth threshold, the detection subsystem 128 can identify the detectable region. For example, when the read depth of one or more sequence fragments is higher than the depth threshold one, the detection subsystem 128 can identify the detectable region in the sequencing data. After identifying the detectable region, the detection subsystem 128 can pass the detectable region to the genotyping subsystem 130, which can convert the detectable region into an active region for generating a potential position in which a variant may exist in the active region. The genotyping subsystem 130 can identify whether the potential position includes the probability or detection score of the variant.

[0037] Figure 2A Included is a diagram 200 illustrating an example of a detectable region based on the read depth of a genomic region in sequencing data. Figure 2A As shown, the sequencing data may include multiple short subsequences or reads 202 having partial DNA information. The reads 202 may overlap at a given reference base position or nucleotide. For example, at a given genomic region 204 in the sequencing data, there may be 8 overlapping reads 202. Therefore, the genomic region 204 in the sequencing data may have a read depth of 8. At another genomic region 206 in the sequencing data, there may be 4 overlapping reads 202. Therefore, the genomic region 206 in the sequencing data may have a read depth of 4. The read depth may be the number of mapped reads at each base position in the sequencing data. For example, the genomic regions 204, 206 may each include one or more reference base positions.

[0038] As described herein, the detectable region 212 can be identified by the detection subsystem of the variant detector based on the read depth of the sequencing data. The detection subsystem of the variant detector can identify that the read depth of the detectable region 212 reaches or exceeds the detectable region depth threshold at the position 208 in the sequencing data. The detectable region depth threshold can be (for example) a read depth of zero or one, so that the detectable region 212 can start when the read depth is detected. However, other depth thresholds can be implemented. The detectable region 212 can continue to be stored by the detection subsystem in a memory (for example, as Figure 1B The genotyping subsystem of the variant caller may be buffered in a RAM 125 (shown) for sending to the genotyping subsystem of the variant caller for detecting a variant in the detectable region 212. The calling subsystem may identify that the read depth reaches or falls below the detectable region depth threshold at position 210 in the sequencing data, and identifies the end of the detectable region 212. The detectable region 212 may then be sent to or accessed by the genotyping subsystem of the variant caller for detecting a variant in the detectable region 212.

[0039] Reference again Figure 1B , as long as the read depth of the detectable region is above the detectable region depth threshold in the sequencing data, the detection subsystem 128 of the variant detector subsystem 126 may continue to buffer the detectable region in the RAM 125. The detection subsystem 128 may attempt to buffer the entire detectable region in the RAM 125 so as not to lose the sequence context in the sequencing data, which can be used to perform variant calling in any genomic region of the sequencing data at the genotyping subsystem 130. The sequence context may include one or more reads and / or bases upstream and / or downstream of the sequence starting from a position on the sequence. The detectable region may include a set of sequences aligned to the same region of a reference genome or sequence, which may be referred to as a pile-up. The pile-up may include a set of reads overlapping the same position with a read depth. The detectable region may include a span of a reference position, wherein the sample sequence is piled up to a certain depth aligned with the reference position. The depth may be indicated by a threshold or a value indicating the pile-up. For example, the detectable region may include a span of a reference position, wherein the sample sequence is piled up to a depth greater than a threshold or a value. Because sample sequences in the callable region are stacked to a greater depth, there may be greater confidence in the variant calls performed.

[0040] As these checkout areas continue to be buffered and / or continue to accumulate, they may exceed the space allocated in RAM 125 for the checkout subsystem 128. In one example, the allocated space in RAM 125 for the checkout area may be 14 GB, 20 GB, or another level of allocated memory in RAM 125. In an example, the total memory available for allocation in RAM 125 may be 40 GB of RAM. The checkout area may exceed this allocation and / or other allocations.

[0041] When processing sequencing data, the sequencing subsystem 104 may be required to remain within the global memory limits in RAM 125 and / or on a hard disk drive (HDD) or disk 123. RAM 125 and disk 123 may be different types of memory or storage devices. RAM 125 may be used to store programs and data that can be used in real time by a processor on a server device 102 that operates the sequencing subsystem 104. RAM 125 may be volatile and may be erased when the computing device is turned off. Disk 123 may be a permanent or non-volatile memory for storing user-specific data, programs, and files that may be accessed when the computing device is turned on after being turned off. For example, the sequencing subsystem 104 and / or its subsystems may be stored on disk 123 as computer executable instructions that may be loaded into RAM 125 to operate as described herein. Disk 123 may be a network storage device (e.g., a cloud storage system) that includes permanent storage shared on one or more computing devices on a network.

[0042] To keep the sequencing subsystem 104 within global memory limits during operation, each subsystem may be allocated or imposed its own memory limits within RAM 125 and / or on disk 123. Exceeding these memory limits may cause the operation of individual subsystems to operate more slowly or crash, may cause the sequencing subsystem 104 as a whole to operate more slowly or crash, and / or may cause other applications operating on the server device 102 on which the sequencing subsystem 104 is operating to operate more slowly or crash. To prevent these memory limits from being exceeded for a given subsystem, the sequencing subsystem 104 and / or an operating system operating on one or more server devices 102 may monitor the amount of memory being utilized by a given subsystem and cancel or suspend the operation of the subsystem to prevent the memory limits from being exceeded.

[0043] These memory limitations may be particularly difficult for the detection subsystem 128 of the variant detector subsystem 126. As described herein, as the detectable region identified by the detection subsystem 128 continues to grow in size, the size of the detectable region may exceed the memory limit allocated and / or imposed by the detection subsystem 128 in RAM 125 before the detectable region is passed to the genotyping subsystem 130. The size of the detectable region may grow due to the number of reads in various portions of the detectable region. For example, given a genome sequenced to an average depth of 300, a portion of the detectable region may occupy a large amount of memory allocated to the detection subsystem 128 in RAM 125. Similarly, as the genomic length of the detectable region grows, the memory allocated to the detection subsystem 128 in RAM 125 may similarly be occupied and / or exceeded. Therefore, the detection subsystem 128 may not be able to fit the entirety of each detectable region into the allocated memory buffer in the RAM 125, especially as the depth of these detectable regions continues to increase for genome sequencing analysis. When the detectable regions reach the allocated memory in the RAM 125 (e.g., 20 GB), the detection subsystem 128 may continue to search for available memory, causing the detection subsystem 128 and / or the variant detector subsystem 126 to stop because the allocated memory for the subsystem has been limited. After a period of time, the operation of the variant detector subsystem 126 may be canceled or paused to free up memory resources in the RAM 125.

[0044] In addition to RAM 125, each of the subsystems may also access storage in disk 123. Disk 123 may include non-volatile memory or permanent memory. Therefore, variant detector subsystem 126 and / or detection subsystem 128 may overflow the detectable area to disk 123. However, each time data is transferred to or read from disk, there is a greater cost in terms of processing resources in writing data to disk 123 and reading data from disk 123 compared to accessing the same data from RAM 125. There may also be greater processing costs when performing compression / decompression of data stored on disk 123. These processing costs may reduce the performance of other subsystems in sequencing subsystem 104 and / or other applications operating on server device 102.

[0045] In order to reduce the processing costs associated with reading and writing to the disk 123, each subsystem in the sequencing subsystem 104 may attempt to operate within the memory allocated to the subsystem. In order to operate within the memory allocated to the detection subsystem 128, the detection subsystem 128 may monitor the memory in the RAM 125 that is being used to buffer the detectable region. When the buffered memory reaches a memory threshold of the total amount of RAM 125 allocated to the detection subsystem 128, the detection subsystem 128 may split the detectable region into two or more genomic regions. For example, the memory threshold may be set to a percentage of the total allocated memory in the RAM 125 for the detection subsystem 128 (e.g., 70% or 75%). In another example, the memory threshold may be set to a predetermined amount of memory (e.g., 1 GB), which may cause the detection subsystem 128 to perform the split at or near each threshold amount of memory. The memory threshold may be fixed or dynamic, as further described herein, so that the detectable region is split at different locations. Even if the detectable region is not reduced to the detectable region depth threshold, the segmentation can be forced to reach the end of the detectable region in RAM 125. The detection subsystem 128 can scan the reads before and / or after the position in the sequence data that reaches the memory threshold, and move the segmentation earlier or later in an attempt to prevent the loss of variants (e.g., due to sequence context). After the segmentation, the detection subsystem 128 can pass the segmentation downstream to the genotyping subsystem 130. In one example, the segmentation can be passed by sending a pointer to the read of the segmented portion to the genotyping subsystem 130. The memory (e.g., RAM) can keep the read occupation of the segmented portion for processing by the genotyping subsystem 130. The genotyping subsystem 130 can convert part of the detectable region into an active region for generating potential positions where variants may exist in the active region. The genotyping subsystem 130 can identify the probability or detection score of whether the potential position includes a variant in the active region. After the genotyping subsystem 130 processes the reads in the sequencing data, memory (eg, RAM) may be freed up to receive additional sequencing data.

[0046] When the buffered memory reaches a memory threshold of the total amount of RAM 125 allocated to the detection subsystem 128, the detection subsystem 128 may send the entire buffered portion of the detectable area to the genotyping subsystem 130 to release the entire buffer. In another example, the detection subsystem 128 may identify another position in the buffered sequencing data for segmentation. For example, the detection subsystem 128 may analyze the read depth of the buffered sequencing data to identify the position for segmentation. The detection subsystem 128 may identify a portion of the sequencing data having a read depth below a segmentation threshold for segmentation. The segmentation threshold may be set to a read depth greater than the detectable area depth threshold. However, the segmentation threshold may be set to a read depth that prevents the loss of additional sequence context around the segmentation position, which may be used by the genotyping subsystem 130 to more accurately predict variants during variant calling.

[0047] Figure 2B Included is a diagram 200a illustrating an example in which the locations of detectable regions may be segmented based on the read depth of the genomic region in sequencing data. Figure 2B The sequencing data shown in Figure 200a in FIG. Figure 2A 200 shown in FIG. However, the detection subsystem may monitor the buffered memory in the RAM and identify that the memory threshold has been reached at a position 216 within the sequencing data. The detection subsystem may then analyze the buffered sequencing data to identify a position 214 where the read depth is at or below the segmentation threshold. The detectable region 212 may be segmented at position 214 (e.g., when the segmentation threshold is set to a read depth of 3), and the segmented portion 218 may be sent downstream to the genotyping subsystem for variant detection. Since the segmentation threshold may be met at various positions within the buffered sequencing data, the detection subsystem may identify the position 214 where the maximum amount of data will be cleared from the buffer. The remainder 220 of the detectable region 212 may remain in the buffer, and the detection subsystem may continue to buffer the sequence data until the detectable region depth threshold or another memory threshold is reached.

[0048] The detection subsystem may use additional logic that enables the detection subsystem to perform more intelligent segmentation in the detectable region within the sequencing data. For example, the detection subsystem may identify that a memory threshold has been reached, or that the sequencing data is within a predetermined amount of occupied memory that reaches the memory threshold, and scan the buffered sequencing data to identify the location where the segmentation is performed to prevent the loss of variants at the genotyping subsystem. The detection subsystem may implement a dynamic memory threshold and / or a dynamic segmentation threshold. The dynamic threshold may allow for more intelligent segmentation based on the amount of memory occupied in the buffer and the read depth of the sequencing data.

[0049] Figure 2CIncluded is a diagram 200b illustrating another example of segmenting the locations of detectable regions based on the read depth of the genomic region in the sequencing data. Figure 2C The sequencing data shown in Figure 200b can be similar to Figure 2A and Figure 2B The sequencing data in Figure 200 and Figure 200a are shown. Figure 2C As shown, the detection subsystem can analyze the buffered sequencing data to identify one or more positions 214a, 214b for segmenting the detectable region 212. For example, the detection subsystem can segment the detectable region 212 into one or more genomic regions based on a predetermined low-end segmentation threshold. Whenever the low-end segmentation threshold is met or exceeded, the detection subsystem can segment the detectable region 212. The low-end segmentation threshold can be higher than the detectable region depth threshold. Figure 2C As shown, the low-end segmentation threshold can be set to a depth threshold of 3, which can cause the detection subsystem to segment the detectable region 212 whenever the segmentation threshold is met or exceeded in the sequencing data. The predetermined low-end segmentation threshold can prevent the loss of sequence context by segmenting the detectable region 212 at a position in the sequencing data where the read depth is relatively lower than other regions in the sequencing data, so there is less data loss when performing variant calls at the genotyping subsystem, and there is a lower variant confidence level at the segmentation due to the lower depth compared to if the segmentation occurs at a position in the sequencing data with a higher depth. In order to avoid the loss of sequence context and / or perform multiple segmentations in a genomic region that does not occupy at least the minimum level of available buffer for storage, the detection subsystem can set a low-end memory threshold for segmentation. For example, the segmentation at position 214a can be performed after the low-end memory threshold has been met or exceeded in the buffer. After the segmentation at 214a, the segmented portion 218a can be sent to the genotyping subsystem for identifying variants.

[0050] During identification of the detectable region 212, the lower segmentation threshold and / or the lower memory threshold may be configured and / or dynamically updated by the user. For example, the lower segmentation threshold and / or the lower memory threshold may be configured and / or dynamically updated based on user input (e.g., from Figure 1A The low-end segmentation threshold may also or alternatively be dynamically updated based on the amount of available memory remaining in the buffer. For example, the low-end segmentation threshold may be increased to a predetermined read segment depth as the amount of space occupied by the detectable region 212 in the buffer increases. Figure 2C As shown, the calling subsystem may determine to segment the detectable region 212 at position 214b of the sequencing data having a higher read depth than position 214a. After segmentation at 214b, the segmented portion 218b may be sent to the genotyping subsystem for identification of variants.

[0051] The detection subsystem may include at least a portion of the logic within the genotyping subsystem for identifying variants at the genotyping subsystem to prevent loss of variants or loss of context to improve the ability to predict variants. For example, the detection subsystem may identify insertions, deletions, or other variants or mutations within a portion of the sequencing data and prevent segmentation of a detectable region within a predetermined region of the insertion or deletion.

[0052] Figure 2D Included is a diagram 200c illustrating another example of locations for segmenting detectable regions into genomic regions in sequencing data. Figure 2D The sequencing data shown in Figure 200c can be similar to Figure 2A , Figure 2B and Figure 2C The sequencing data in Figures 200, 200a and / or 200b shown. Figure 2D As shown, the detection subsystem may detect that a memory threshold and / or a segmentation threshold of the detectable region 212 has been reached, and identify a position 214d for performing segmentation in the detectable region 212. For example, the detection subsystem may identify position 214d based on the read depth of the sequencing data at position 214d. The detection subsystem may then analyze the buffered sequencing data to determine whether there is an insertion, deletion, or other variant or mutation within a predetermined proximity (e.g., genomic region 226) of the identified segmentation position 214d. The genomic region 226 may be a predetermined number of bases (e.g., 100 bases, 1000 bases, etc.), a predetermined number of buffer positions, and / or a predetermined amount of memory. For example, the detection subsystem may analyze each read 202 and compare the read 202 with a reference sequence to detect a variant or mutation at a genomic portion 222 of one or more reads 202. The genomic portion 222 may include one or more bases themselves. Bases within the genomic portion 222 may be identified at a starting base or starting index and / or an ending base or ending index.

[0053] The detection subsystem can use population data to identify variants or mutations in the genome portion 222 that are more likely (or more common) for the population corresponding to the sample genome. Therefore, the detection subsystem can use various frequencies and / or population data, which represent the possibility of insertion, deletion, structural variant, copy number variant or other variant or mutation occurring in the genome region 222 and / or the size of the genome region 222. The detection subsystem can access a database including population data. The database can indicate the genome sequence and corresponding genome coordinates of a given population or race. The database can also include metadata indicating the surrounding nucleotide bases common to the population or race. The detection subsystem can determine and use the population data corresponding to the sample genome. For illustration, in some embodiments, the detection subsystem can identify or receive data about the population and / or race corresponding to a specific sample genome. Therefore, the detection subsystem can identify variants or mutations from bases or genome portions common to the population or race. For illustration, in one or more embodiments, the detection subsystem can use a reference genome corresponding to the identified population or race corresponding to the sample genome. The call subsystem may identify a genomic region that includes an insertion, deletion, structural variant, copy number variant, or other variant or mutation, or other variant or mutation at a genomic coordinate within a genomic region, such as genomic region 222. The call subsystem may also identify the size of genomic region 222 based on a reference genome corresponding to the identified population or ethnicity.

[0054] The detection subsystem can use data about populations and / or ethnicities to identify insertions, deletions, structural variants, copy number variants, or other variants or mutations at genomic coordinates or target genomic regions of the sample genome. For illustration, the detection subsystem can identify variants or mutations within a genomic region 222 based on surrounding nucleotide bases within the genomic region. Based on the nucleotide bases within the genomic region, the detection subsystem can identify the likelihood of an insertion, deletion, structural variant, copy number variant, or other variant or mutation at a genomic coordinate or region.

[0055] When the detection subsystem detects that a variant or mutation at a genomic portion 222 is within a predetermined genomic region 226 of the identified segmentation position 214d, the detection subsystem may prevent the segmentation from occurring at position 214d. The detection subsystem may identify another position 214c for performing the segmentation within the buffer portion of the detectable region 212. Position 214c may be at least a predetermined genomic region 224 from the genomic portion 222 (e.g., a starting index or starting base from the genomic portion 222). The genomic region 224 may be a predetermined number of bases (e.g., 100 bases, 1000 bases, etc.), a predetermined number of buffer positions, and / or a predetermined amount of memory. The genomic region 224 may be the same as or different from the genomic region 226. The segmentation of the detection region 212 at position 214c, which is at least the predetermined genomic region 224, may prevent the loss of sequence context at or near the variant or mutation detected by the variant at the genotyping subsystem.

[0056] The genomic regions 224, 226 may be changed dynamically or otherwise based on the type of sequencing data being analyzed. For example, the genomic regions 224, 226 may be determined based on population data. The detection subsystem may identify the number of bases used as sequencing contexts for insertion, deletion, structural variant, copy number variant or other variant or mutation based on population data. The detection subsystem may update the genomic regions 224, 226 based on the number of bases indicated in the population data. Variants or mutations may not be evenly distributed in the genome. Using population data, positions may be conservative (e.g., rarely have mutations), and segmentation may be performed at these positions to attempt to avoid segmentation within the genomic regions 224, 226 of variants or mutations.

[0057] The detection subsystem may attempt to identify a position 214c with a predetermined read depth of the segmentation threshold from the genomic portion 222 for identifying another segmentation. If the detection subsystem fails to find a position with a predetermined read depth of the segmentation threshold in the sequencing data, the segmentation threshold may be dynamically updated to allow for a higher or lower read depth, or the detection subsystem may fail to perform another segmentation between the position 208 at the beginning of the detectable region 212 and the genomic portion 222 containing the variant or mutation. The detection subsystem may then look for a segmented detectable region 212 after the genomic portion 222 containing the variant or mutation. The detection subsystem may attempt to segment the detectable region 212 from the genomic portion 222 at a location outside of the genomic region 224. The memory threshold may have to be increased to accommodate the segmentation while maintaining the context around the variant or mutation.

[0058] As described herein, the segmentation of the detectable region 212 can cause the loss of sequencing context that can be used by the genotyping subsystem for accurate variant detection. In order to retain the sequencing context and prevent other loss of sequencing data when the detectable region 212 is segmented, the detection subsystem can maintain the overlap of data from the detectable region 212 in the buffer and send multiple segmented portions of the detectable region including overlapping data to the genotyping subsystem. The genotyping subsystem can identify overlapping data and discard any duplicate data. However, overlapping data can help ensure that the sequencing context and / or other data around the segmentation are retained for variant detection.

[0059] Figure 2E Included is a diagram 200d illustrating another example of locations for segmenting detectable regions into genomic regions in sequencing data. Figure 2E The sequencing data shown in Figure 200d in FIG. Figure 2A , Figure 2B , Figure 2C and Figure 2D The sequencing data in Figures 200, 200a, 200b and / or 200c shown. Figure 2E As shown, the detection subsystem can detect that the memory threshold and / or the segmentation threshold of the detectable area 212 has been reached, and identify the position 214f ​​for performing the segmentation in the detectable area 212. For example, the detection subsystem can identify the position 214f ​​based on the read depth of the sequencing data at the position 214f. The detection subsystem can send the segmentation portion 218c to the genotyping subsystem for identification of variants. The segmentation portion 218c may include sequencing data from the segmented position 214f ​​and the beginning of the detectable area 212 or the previously segmented position.

[0060] After the segmentation portion 218c is sent to the genotyping subsystem, the detection subsystem can maintain an overlapping portion 230 of the sequencing data in the memory. The overlapping portion 230 can be a predetermined portion of the sequencing data from position 214f ​​to position 214e. The predetermined portion can be a predetermined number of bases (e.g., 100 bases, 1000 bases, etc.), a predetermined number of buffer positions, and / or a predetermined amount of memory. The predetermined number of bases, the number of buffer positions, and / or the amount of memory can be predetermined and / or user defined based on user input. The overlapping portion 230 can be changed dynamically. For example, the overlapping portion 230 can be changed based on population data. The overlapping portion 230 can be defined by the read depth. For example, the detection subsystem can identify the position 214e based on the predetermined read depth at the position 214e, for defining the overlapping portion 230 of the sequencing data from the segmented position 214f. The genotyping subsystem may maintain a pointer or update a pointer to the read 202 in the overlap 230 so that the memory of the detection subsystem 128 continues to be occupied by the read 202 in the overlap 230. When the detection subsystem identifies a subsequent position for segmenting the detectable region 212, or reaches a position 210 at the end of the detectable region 212, the detection subsystem may send the remaining portion 220 of the detectable region 212 to the genotyping subsystem for variant calling. The detection subsystem may analyze the segment 218c and determine based on the data in the segment 218c that the overlap is not maintained. The genotyping subsystem may identify the overlap and remove duplicate bases before performing variant calling. Maintaining overlapping data near the segmentation prevents data loss at or near the segmentation.

[0061] Figure 3 1 is a flow chart of a process 300 for segmenting detectable regions into genomic regions in sequencing data based on a memory threshold. The process 300 may be performed by one or more computing devices. For example, the process 300 may be performed by a sequencing subsystem (e.g., Figure 1A and Figure 1B One or more server devices (e.g., Figure 1A The process 300 may be performed by a server device 102 as shown in the figure) and / or a sequencing device (e.g., sequencing device 114). The process 300 may be performed by one or more subsystems of the sequencing subsystem. For example, the process 300 may be performed by a detection subsystem (e.g., Figure 1B300). Although the detection subsystem may be provided as an exemplary subsystem for performing process 300, one or more portions of process 300 may be performed by one or more systems and / or subsystems, such as a sequencing subsystem and / or one or more subsystems therein. Process 300 may be performed on a single computing device or may be distributed across multiple computing devices. For example, process 300 may be performed as computer executable instructions retrieved from a memory by one or more processors on one or more computing devices.

[0062] like Figure 3 As shown, at 302, the detection subsystem may receive sequencing data including a plurality of read segments of a genomic sequence. At 304, the detection subsystem may identify the start of a detectable region in the sequencing data. For example, the detectable region may be identified at the beginning of the sequence data and / or when the sequencing data reaches a detectable region depth threshold. The detectable region depth threshold may be a value of zero or one. The detectable region depth threshold may be predetermined or dynamic, as described herein. The detectable region depth threshold at the start of the detectable region may be the same as or different from the detectable region depth threshold at the end of the detectable region.

[0063] At 306, the detection subsystem may monitor the memory for storing sequencing data in the detectable region. The detectable region may be buffered in RAM by the detection subsystem in an attempt to identify the detectable region in RAM and send the detectable region to the genotyping subsystem for variant detection within the detectable region. The memory threshold may be predetermined or dynamic, as described herein. For example, the memory threshold may be set to a relatively large portion (e.g., bytes, percentage, etc.) of the total allocated memory for storing the detectable region of the sequencing data (e.g., 70%, 75%, etc.) to send a relatively large portion of the detectable region to the genotyping subsystem, or to a relatively small portion (e.g., bytes, percentage, etc.) of the total allocated memory for storing the detectable region of the sequencing data (e.g., 25%, 30%, etc.) to send a relatively small portion of the detectable region to the genotyping subsystem.

[0064] At 308, the detection subsystem may determine whether the memory being used to store the detectable region has reached a memory threshold for the allocated memory for storing the detectable region. If the memory threshold has not yet been reached, then at 314, the detection subsystem may monitor the sequence data to determine whether the end of the detectable region has been reached. For example, when the sequencing data reaches the detectable region depth threshold, the detection subsystem may identify the end of the detectable region in the sequencing data. For example, the detectable region depth threshold may be a value of zero or one. When the end of the detectable region is identified, at 316, the detection subsystem may send the detectable region downstream to the genotyping subsystem for variant detection. If the end of the detectable region has not yet been reached, then the detection subsystem may continue to receive sequencing data at 315, and continue to monitor the memory used to store the detectable region and / or monitor the end of the detectable region at 306.

[0065] If the detection subsystem determines at 308 that the memory threshold has been reached, the detection subsystem may determine at 310 a location in the sequencing data at which to split the detectable region. The detectable region may be split to preserve memory resources allocated to the detection subsystem, the sequencing subsystem, and / or a computing device on which the detection subsystem may operate. At 310, the detection subsystem may determine to split the detectable region at a location in the sequencing data at which the memory threshold has been reached, so that the detection subsystem sends the entirety of the buffered sequencing data including a portion of the detectable region to the genotyping subsystem. As described herein, the detectable region may be split by analyzing the buffered portion of the detectable region to identify another location to perform the split. For example, the split may be performed at one location to reduce the amount of sequencing context that may be lost; avoid the loss of variants; avoid splitting within a predetermined region of a variant and / or mutation, such as an insertion, deletion, structural variant, copy number variant, or another variant or mutation; and / or retain data in other ways when performing the split.

[0066] At 310, the location of the segmentation can be determined based on a segmentation threshold. The segmentation threshold can be set to a read depth that is higher than a detectable region depth threshold. As described herein, the detection subsystem can analyze the region where the segmentation can be performed to determine whether to segment the detectable region at another location. For example, the detection subsystem can identify an insertion, deletion, or other variant or mutation within a predetermined proximity of the segmentation location, and identify another location for performing the segmentation. The location of the segmentation can be performed to retain sequence context data, which can be used by the genotyping subsystem to identify variants. The location of the segmentation can be performed based on population data, as described herein.

[0067] At 312, the segmented portion of the detectable area can be sent downstream to the genotyping subsystem for variant detection. The genotyping subsystem can begin to analyze the segmented portion of the detectable area to identify variants. The detection subsystem can maintain a portion of the segmented portion of the detectable area in a buffer so that the overlapping portion of two consecutive portions of the detectable area has an overlap when they are received by the genotyping subsystem. The genotyping subsystem can identify the overlapping portion and remove repeated bases before performing variant detection. Maintaining overlapping data near the segmentation can prevent data loss at or near the segmentation. If the location where the segmentation is performed is not the end of the detectable area, the detection subsystem can continue to receive sequencing data at 315, and monitor the memory for storing the detectable area and / or monitor the end of the detectable area at 306.

[0068] Embodiments for dividing a detectable region into one or more parts to operate within a memory allocation in RAM for storing the detectable region are described herein. Alternatively or additionally, the detectable region or a portion thereof may overflow to a disk to operate within a memory allocation in RAM. The disk may include a non-volatile memory or a permanent storage device. In order to avoid incorrect variant detection and retain the sequence context for performing variant detection at the genotyping subsystem, a portion of the detectable region may be overflowed to the disk by the detection subsystem and may be streamed back from the disk by the genotyping subsystem of the variant detector for further analysis. For example, if the detectable region reaches an overflow threshold, which may be a memory threshold or a threshold number of bases, the detectable region may be overflowed to the disk. The detectable region may overflow to the disk to avoid the risk of losing variant detection at the segmented position. The reads in the detectable region may be written to the disk to retain the detectable region.

[0069] Reference again Figure 1B , the detection subsystem 128 of the variant detector subsystem 126 can receive the aligned and sorted sequencing data, and can identify detectable regions with sufficient alignment coverage. The detectable regions can be identified based on the read depth, as described herein. The detectable regions can be regions that are passed downstream to the genotyping subsystem 130 for detecting variants from the detectable regions. For example, the genotyping subsystem 130 can compare the detectable regions with the reference genome for detecting variants.

[0070] As long as the read depth of the detectable region is above the detectable region depth threshold in the sequencing data, the detection subsystem 128 can continue to buffer the detectable region in the RAM 125. In order to operate within the memory allocated to the detection subsystem 128, the detection subsystem 128 can monitor the memory in the RAM 125 that is being used to buffer the detectable region. When the buffered memory reaches the memory threshold of the total amount of RAM 125 allocated to the detection subsystem 128, the detection subsystem 128 can overflow the detectable region to the disk 123 (e.g., HDD). The memory threshold can be the same as or different from the memory threshold for segmenting the detectable region described herein.

[0071] The calling subsystem 128 may overflow the entirety of the detectable region to disk 123 and store as a file accessed by the downstream genotyping subsystem 130 when performing variant calling. The calling subsystem 128 may call a function in the genotyping region, thereby giving the calling subsystem 128 the start and end pointers of the detectable region and instructing the calling subsystem 128 to analyze the reads in the detectable region. When a portion of the detectable region is overflowed to disk, the calling subsystem 128 may pass information about how to access the reads stored to disk (e.g., using a file name or other identifier). The genotyping subsystem 130 may load the entire detectable region into RAM 125, or stream the overflowed portion of the detectable region from disk 123 back to RAM 125. In another example, the calling subsystem 128 may maintain in RAM 125 the portion of the detectable region that was buffered before reaching the memory threshold, and overflow the rest of the detectable region to disk. The calling subsystem 128 may update the pointer in the RAM 125 to send the portion of the callable region in the RAM 125 to the genotyping subsystem 130. The genotyping subsystem 130 may begin processing the portion of the callable region received in the RAM 125, and then when the RAM 125 allocated to the genotyping subsystem is freed, stream the portion of the callable region from the disk 123 into the RAM 125. Since the genotyping subsystem 130 may be allocated a larger portion of the RAM 125 than the calling subsystem, the genotyping subsystem 130 is able to load a larger portion of the callable region into the RAM 125 as the callable region is processed.

[0072] The genotyping subsystem 130 may stream the overflowed portion of the detectable region from the disk 123 into the RAM 125, and perform an initial analysis to determine whether to maintain the sequencing data in the streamed portion in the RAM 125 before accessing additional portions of the overflowed detectable region from the disk 123. For example, the genotyping subsystem 130 may stream a first portion (e.g., 1 GB, 2 GB, etc.) of the reads in the detectable region from the disk 123, and perform an initial analysis to determine whether the first portion of the reads includes an insertion, a deletion, or another variant or mutation. The genotyping subsystem 130 may discard the portion of the reads in the detectable region in the RAM 125 that will not be used for variant calling (e.g., variants or sequence context for variant calling), and stream the second portion of the detectable region from the disk 123. The genotyping subsystem 130 may continue to stream portions of the detectable region from the disk 123 to load portions of the detectable region into the RAM 125 to be used for variant calling. The genotyping subsystem 130 may continue to monitor the amount of detectable regions loaded into the RAM 125 and limit the amount of detectable regions streamed from the disk 123 before processing the detectable regions using a memory threshold for the amount of memory allocated to the genotyping subsystem 130 to free up portions of the RAM 125 before uploading additional portions of the detectable regions. The memory threshold may be a separate memory threshold that is a predetermined amount of data less than the allocated memory of the genotyping subsystem 130.

[0073] Overflowing the detectable area to disk 123 can allow the detection subsystem 128 to operate within the memory allocation for the detectable area without losing the sequence context that can be used to perform variant calls. Maintaining a portion of the detectable area in RAM 125 can also save processing / compression that can be used to write / read to / from disk 123 by sending less data to disk 123.

[0074] Figure 4 4 is a flow chart of a process 400 for overflowing a detectable region to disk based on a memory threshold. The process 400 may be performed by one or more computing devices. For example, the process 400 may be performed by a sequencing subsystem (e.g., Figure 1A and Figure 1B One or more server devices (e.g., Figure 1A Process 400 may be performed by one or more subsystems of a sequencing subsystem. For example, process 400 may be performed by a call subsystem and / or a genotyping subsystem (e.g., Figure 1BThe process 400 may be performed by the detection subsystem 128 and / or genotyping subsystem 130 shown. Although the detection subsystem and the genotyping subsystem may be provided as exemplary subsystems for performing portions of process 400, one or more portions of process 400 may be performed by one or more systems and / or subsystems, such as a sequencing subsystem and / or one or more subsystems therein. Additionally, although one of the detection subsystem or the genotyping subsystem may be described as performing one or more features herein, these features may be performed by another subsystem. Process 400 may be performed on a single computing device or may be distributed across multiple computing devices. For example, process 400 may be performed as computer executable instructions retrieved from a memory by one or more processors on one or more computing devices.

[0075] like Figure 4 As shown, at 402, the detection subsystem may receive sequencing data including a plurality of read segments of a genomic sequence. At 404, the detection subsystem may identify the start of a detectable region in the sequencing data. For example, the detectable region may be identified at the beginning of the sequence data and / or when the sequencing data reaches a detectable region depth threshold.

[0076] At 406, the detection subsystem may monitor the memory used to store the sequencing data in the detectable region. The detectable region may be buffered in RAM by the detection subsystem in an attempt to identify the detectable region in RAM and send the detectable region to the genotyping subsystem for variant calling within the detectable region. The memory threshold may be set to a portion (e.g., bytes, percentage, etc.) of the total allocated memory for storing the detectable region of the sequencing data (e.g., 70%, 75%, etc.).

[0077] At 408, the detection subsystem may determine whether the memory being used to store the detectable region has reached a memory threshold for the allocated memory for storing the detectable region. If the memory threshold has not been reached, then at 414, the detection subsystem may monitor the sequence data to determine whether the end of the detectable region has been reached. When the sequencing data reaches the detectable region depth threshold, the detection subsystem may identify the end of the detectable region in the sequencing data. For example, the detectable region depth threshold may be a value of zero or one. When the end of the detectable region is identified, at 416, the detection subsystem may send the detectable region downstream to the genotyping subsystem for performing variant detection at 418. If the end of the detectable region has not been reached, then the detection subsystem may continue to receive sequencing data at 415, and continue to monitor the memory for storing the detectable region and / or monitor the end of the detectable region at 406.

[0078] If the detection subsystem determines at 408 that the memory threshold has been reached, the detection subsystem may determine at 410 to overflow the detectable region to disk. The entirety of the detectable region may overflow to disk, or a portion of the detectable region may be maintained in RAM. For example, the portion of the detectable region that has been buffered before the memory threshold is reached at 408 may be maintained in RAM and sent downstream to the genotyping subsystem for processing. The detection subsystem may send the portion of the detectable region maintained in RAM downstream to the genotyping subsystem by updating a pointer in a buffer to maintain the portion of the detectable region in RAM. The overflowed portion of the detectable region may be compressed and / or stored to disk.

[0079] At 412, the genotyping subsystem may stream the detectable region from the disk. For example, at 412, the genotyping subsystem streams the entire detectable region or a portion thereof from the disk to the RAM. The streaming of the detectable region may include decompressing the detectable region. The genotyping subsystem may stream a portion of the detectable region from the disk to the RAM, and analyze the portion of the detectable region to determine whether to discard one or more portions of the detectable region to release additional RAM that may not be used for variant calling. For example, the genotyping subsystem may analyze each read in the region. If the read is equal to the reference, it can be determined that the read does not include a variant, and the read can be discarded or ignored. The genotyping subsystem may also identify and discard or ignore sequencing errors. When the detectable region is streamed from the disk, the genotyping subsystem may monitor another memory threshold to ensure that when the detectable region is streamed from the disk, the memory allocation for the genotyping subsystem in the RAM is not exceeded. The genotyping subsystem may use the detectable region or a portion thereof uploaded to the RAM to perform variant calling and / or genotyping. At 418, one or more portions of the detectable region may be used to perform variant calling.

[0080] Figure 5 is a block diagram illustrating an exemplary computing device 500. One or more computing devices, such as computing device 500, may implement a method for generating and / or processing one or more features of a detectable region, as described herein. For example, computing device 500 may include Figure 1A One or more of the genotyping device 114, the client device 108, and / or the server device 102 shown. Figure 5 As shown, computing device 500 may include processor 502, memory 504, storage device 506, I / O interface 508, and / or communication interface 510, which may be communicatively coupled by way of communication infrastructure 512. It should be understood that computing device 500 may include more than one embodiment of the present invention. Figure 5 Fewer or more components than those shown.

[0081] The processor 502 may include hardware for executing instructions, such as those constituting a computer program. In an example, in order to execute instructions for dynamically modifying a workflow, the processor 502 may retrieve (or extract) instructions from an internal register, an internal cache, a memory 504, or a storage device 506, and decode and execute the instructions. The memory 504 may be a volatile or non-volatile memory for storing data, metadata, computer-readable or machine-readable instructions and / or programs for execution by the processor to operate as described herein. The memory 504 may include RAM. The storage device 506 may include a storage device for storing data or instructions for executing the methods described herein, such as a hard disk, a flash drive, or other digital storage device.

[0082] The I / O interface 508 may allow a user to provide input to the computing device 500, receive output from the computing device, and / or otherwise send data to and receive data from the computing device. The I / O interface 508 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 508 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 508 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.

[0083] The communication interface 510 may include hardware, software, or both. In any case, the communication interface 510 may provide one or more interfaces for communication (such as, for example, packet-based communication) between the computing device 500 and one or more other computing devices or networks. The communication may be wired communication or wireless communication. As an example and not by way of limitation, the communication interface 510 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.

[0084] Additionally, the communication interface 510 can facilitate communication with various types of wired or wireless networks. The communication interface 510 can also facilitate communication using various communication protocols. The communication infrastructure 512 can also include hardware, software, or both that couple the components of the computing device 500 to each other. For example, the communication interface 510 can use one or more networks and / or protocols to enable multiple computing devices connected through a specific infrastructure to communicate with each other to perform one or more aspects of the processes described herein. For illustration, a sequencing method 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.

[0085] 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, for example, a computer or processor to execute. Examples of computer-readable media include electronic signals (transmitted via a wired or wireless connection) and tangible / non-transient computer-readable storage media. Examples of tangible / 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).

[0086] Although the present disclosure has been described according to certain embodiments and generally associated methods, the changes and permutations of these 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.

[0087] Terms

[0088] 1. A computer-implemented method comprising:

[0089] Receiving, at a calling subsystem of a variant caller, sequencing data comprising a plurality of reads of a genomic sequence, wherein the calling subsystem of the variant caller is configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is above a detectable region depth threshold, and wherein the calling subsystem of the variant caller is configured to send at least a portion of the detectable region to a genotyping subsystem of the variant caller for variant calling of the detectable region;

[0090] monitoring memory used by the calling subsystem of the variant caller;

[0091] When the memory used by the calling subsystem of the variant caller exceeds a memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller, segmenting the detectable region; and

[0092] The segmented portions of the detectable regions are sent to the genotyping subsystem of the variant caller to make the variant calls based on the segmented portions.

[0093] 2. A computer-implemented method according to clause 1, wherein sending the segmented portion of the detectable region to the genotyping subsystem increases the availability of the memory used by the detection subsystem.

[0094] 3. The computer-implemented method of clause 1, wherein the memory threshold is a fixed threshold.

[0095] 4. The computer-implemented method of clause 1, wherein the memory threshold is a dynamic threshold.

[0096] 5. The computer-implemented method of clause 1, further comprising:

[0097] analyzing the sequencing data at the calling subsystem of the variant caller when the memory used by the calling subsystem of the variant caller is within the memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller;

[0098] identifying variants or mutations in the sequencing data within a predetermined proximity of the identified segment; and

[0099] After identifying the variant or mutation in the sequencing data, the segmenting of the detectable region is performed outside the predetermined proximity of the variant or mutation.

[0100] 6. A computer-implemented method according to clause 5, wherein at least one of the variants or mutations or the predetermined proximity of the identified segmentation is determined based on population data accessed by the detection subsystem.

[0101] 7. A computer-implemented method according to clause 5, wherein the variant or mutation comprises an insertion or a deletion.

[0102] 8. The computer-implemented method of clause 1, further comprising:

[0103] The buffered sequencing data is analyzed to identify locations of the segmentations of the detectable regions within the buffered sequencing data.

[0104] 9. The computer-implemented method of clause 8, further comprising:

[0105] identifying a portion of the buffered sequencing data having a read depth below a segmentation threshold; and

[0106] The segmenting of the buffered sequencing data is performed at the identified portions having the read depth below the segmentation threshold.

[0107] 10. A computer-implemented method according to clause 1, wherein when the depth of the plurality of reads is below the detectable region depth threshold for detecting the detectable region, the detectable region is sent to the genotyping subsystem.

[0108] 11. A computer-implemented method as described in clause 1, wherein the segmented portion of the detectable area is the entirety of the detectable area currently in the memory used by the detection subsystem.

[0109] 12. The computer-implemented method of clause 1, wherein the segment is a first segment, the method further comprising:

[0110] maintaining a predetermined amount of the sequencing data in the first segmented portion of the detectable region in the memory used by the calling subsystem of the variant caller;

[0111] detecting a second segmented portion of the detectable area based on the detectable area depth threshold or the memory threshold; and

[0112] The second segmented portion of the detectable region is sent to the genotyping subsystem of the variant caller to perform the variant calling based on the second segmented portion, wherein the second segmented portion includes an overlap of the sequencing data with the first segmented portion of the detectable region including the predetermined amount of sequencing data.

[0113] 13. A computer-implemented method according to clause 12, wherein the predetermined amount of sequencing data that overlaps is a predetermined number of bases.

[0114] 14. A computer-implemented method according to clause 12, wherein the overlapping predetermined amount of sequencing data is determined based on population data accessed by the detection subsystem.

[0115] 15. A computer-implemented method according to clause 12, wherein the predetermined amount of sequencing data that overlaps is determined based on user input.

[0116] 16. The computer-implemented method of clause 12, further comprising:

[0117] identifying, at the genotyping subsystem of the variant caller, the overlap in the sequencing data between the first segmented portion and the second segmented portion of the detectable region; and

[0118] Prior to performing the variant calling on the detectable region, removing the overlap in the sequencing data between the first segmented portion and the second segmented portion of the detectable region.

[0119] 17. The computer-implemented method of clause 1, wherein the detectable region depth threshold is a first detectable region depth threshold, wherein the segmented portion is a first segmented portion, and the method further comprises:

[0120] monitoring the depth of the plurality of reads at the calling subsystem of the variant caller;

[0121] When the depths of the plurality of read segments are below a second detectable region depth threshold, segmenting the detectable region; and

[0122] A second segmented portion of the detectable region is sent to the genotyping subsystem of the variant caller to make the variant call based on the second segmented portion.

[0123] 18. A sequencing system comprising:

[0124] Memory; and

[0125] at least one processor, the at least one processor being configured to:

[0126] Receiving, at a calling subsystem of a variant caller, sequencing data comprising a plurality of reads of a genomic sequence, wherein the calling subsystem of the variant caller is configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is above a detectable region depth threshold, and wherein the calling subsystem of the variant caller is configured to send at least a portion of the detectable region to a genotyping subsystem of the variant caller for variant calling of the detectable region;

[0127] monitoring the memory used by the calling subsystem of the variant caller;

[0128] When the memory used by the calling subsystem of the variant caller exceeds a memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller, segmenting the detectable region; and

[0129] The segmented portions of the detectable regions are sent to the genotyping subsystem of the variant caller to make the variant calls based on the segmented portions.

[0130] 19. A sequencing system according to clause 18, wherein the at least one processor is configured to send the segmented portion of the detectable region to the genotyping subsystem to increase the availability of the memory used by the detection subsystem.

[0131] 20. A sequencing system according to clause 18, wherein the memory threshold is a fixed threshold.

[0132] 21. A sequencing system according to clause 18, wherein the memory threshold is a dynamic threshold.

[0133] 22. The sequencing system of clause 18, wherein at least one processor is configured to:

[0134] analyzing the sequencing data at the calling subsystem of the variant caller when the memory used by the calling subsystem of the variant caller is within the memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller;

[0135] identifying variants or mutations in the sequencing data within a predetermined proximity of the identified segment; and

[0136] After identifying the variant or mutation in the sequencing data, the segmenting of the detectable region is performed outside the predetermined proximity of the variant or mutation.

[0137] 23. A sequencing system according to clause 22, wherein at least one of the predetermined proximity of the variant or mutation or the identified segmentation is determined based on population data accessed by the detection subsystem.

[0138] 24. A sequencing system according to clause 22, wherein the variant or mutation comprises an insertion or a deletion.

[0139] 25. The sequencing system of clause 18, wherein the at least one processor is further configured to:

[0140] The buffered sequencing data is analyzed to identify locations of the segmentations of the detectable regions within the buffered sequencing data.

[0141] 26. The sequencing system of clause 25, wherein the at least one processor is further configured to:

[0142] identifying a portion of the buffered sequencing data having a read depth below a segmentation threshold; and

[0143] The segmenting of the buffered sequencing data is performed at the identified portions having the read depth below the segmentation threshold.

[0144] 27. A sequencing system according to clause 18, wherein the at least one processor is configured to detect the detectable region when the depth of the plurality of reads is below the detectable region for detecting the detectable region.

[0145] When the depth threshold of the detected area is reached, the detectable area is sent to the genotyping subsystem.

[0146] 28. A sequencing system according to clause 18, wherein the segmented portion of the detectable region is the entirety of the detectable region currently in the memory used by the detection subsystem.

[0147] 29. The sequencing system of clause 18, wherein the segmenting portion is a first segmenting portion, and wherein the at least one processor is further configured to:

[0148] maintaining a predetermined amount of the sequencing data in the first segmented portion of the detectable region in the memory used by the calling subsystem of the variant caller;

[0149] detecting a second segmented portion of the detectable area based on the detectable area depth threshold or the memory threshold; and

[0150] The second segmented portion of the detectable region is sent to the genotyping subsystem of the variant caller to perform the variant calling based on the second segmented portion, wherein the second segmented portion includes an overlap of the sequencing data with the first segmented portion of the detectable region including the predetermined amount of sequencing data.

[0151] 30. A sequencing system according to clause 29, wherein the predetermined amount of sequencing data that overlaps is a predetermined number of bases.

[0152] 31. A sequencing system according to clause 29, wherein the overlapping predetermined amount of sequencing data is determined based on population data accessed by the detection subsystem.

[0153] 32. A sequencing system according to clause 29, wherein the predetermined amount of sequencing data that overlaps is determined based on user input.

[0154] 33. The sequencing system of clause 29, wherein the at least one processor is further configured to:

[0155] identifying, at the genotyping subsystem of the variant caller, the overlap in the sequencing data between the first segmented portion and the second segmented portion of the detectable region; and

[0156] Prior to performing the variant calling on the detectable region, removing the overlap in the sequencing data between the first segmented portion and the second segmented portion of the detectable region.

[0157] 34. The sequencing system of clause 18, wherein the detectable region depth threshold is a first detectable region depth threshold, wherein the segmentation portion is a first segmentation portion, and wherein the at least one processor is further configured to:

[0158] monitoring the depth of the plurality of reads at the calling subsystem of the variant caller;

[0159] When the depths of the plurality of read segments are below a second detectable region depth threshold, segmenting the detectable region; and

[0160] A second segmented portion of the detectable region is sent to the genotyping subsystem of the variant caller to make the variant call based on the second segmented portion.

[0161] 35. At least one computer-readable storage medium having stored thereon computer-executable instructions that, when executed by at least one processor, cause the at least one processor to:

[0162] Receiving, at a calling subsystem of a variant caller, sequencing data comprising a plurality of reads of a genomic sequence, wherein the calling subsystem of the variant caller is configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is above a detectable region depth threshold, and wherein the calling subsystem of the variant caller is configured to send at least a portion of the detectable region to a genotyping subsystem of the variant caller for variant calling of the detectable region;

[0163] monitoring memory used by the calling subsystem of the variant caller;

[0164] When the memory used by the calling subsystem of the variant caller exceeds a memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller, segmenting the detectable region; and

[0165] The segmented portions of the detectable regions are sent to the genotyping subsystem of the variant caller to make the variant calls based on the segmented portions.

[0166] 36. At least one computer-readable storage medium according to clause 35, wherein the computer-executable instructions are configured to cause the at least one processor to: send the segmented portion of the detectable region to the genotyping subsystem to increase the availability of the memory used by the detection subsystem.

[0167] 37. At least one computer-readable storage medium as recited in clause 35, wherein the memory threshold is a fixed threshold.

[0168] 38. At least one computer-readable storage medium as recited in clause 35, wherein the memory threshold is a dynamic threshold.

[0169] 39. The at least one computer-readable storage medium of clause 35, wherein the computer-executable instructions are configured to cause the at least one processor to:

[0170] analyzing the sequencing data at the calling subsystem of the variant caller when the memory used by the calling subsystem of the variant caller is within the memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller;

[0171] identifying variants or mutations in the sequencing data within a predetermined proximity of the identified segment; and

[0172] After identifying the variant or mutation in the sequencing data, the segmenting of the detectable region is performed outside the predetermined proximity of the variant or mutation.

[0173] 40. At least one computer-readable storage medium according to clause 39, wherein at least one of the variants or mutations or the predetermined proximity of the identified segmentation is determined based on population data accessed by the detection subsystem.

[0174] 41. At least one computer-readable storage medium according to clause 39, wherein the variant or mutation comprises an insertion or a deletion.

[0175] 42. The at least one computer-readable storage medium of clause 35, wherein the computer-executable instructions are configured to cause the at least one processor to:

[0176] The buffered sequencing data is analyzed to identify locations of the segmentations of the detectable regions within the buffered sequencing data.

[0177] 43. At least one computer-readable storage medium according to clause 42, wherein the computer-executable instructions are configured to cause the at least one processor to:

[0178] identifying a portion of the buffered sequencing data having a read depth below a segmentation threshold; and

[0179] The segmenting of the buffered sequencing data is performed at the identified portions having the read depth below the segmentation threshold.

[0180] 44. At least one computer-readable storage medium according to clause 35, wherein the computer-executable instructions are configured to cause the at least one processor to: send the detectable region to the genotyping subsystem when the depth of the multiple read segments is lower than the detectable region depth threshold for detecting the detectable region.

[0181] 45. At least one computer-readable storage medium according to clause 35, wherein the segmented portion of the detectable area is the entirety of the detectable area currently in the memory used by the detection subsystem.

[0182] 46. ​​The at least one computer-readable storage medium of clause 35, wherein the partition is a first partition, and wherein the computer-executable instructions are configured to cause the at least one processor to:

[0183] maintaining a predetermined amount of the sequencing data in the first segmented portion of the detectable region in the memory used by the calling subsystem of the variant caller;

[0184] detecting a second segmented portion of the detectable area based on the detectable area depth threshold or the memory threshold; and

[0185] The second segmented portion of the detectable region is sent to the genotyping subsystem of the variant caller to perform the variant calling based on the second segmented portion, wherein the second segmented portion includes an overlap of the sequencing data with the first segmented portion of the detectable region including the predetermined amount of sequencing data.

[0186] 47. At least one computer-readable storage medium according to clause 46, wherein the predetermined amount of sequencing data that overlaps is a predetermined number of bases.

[0187] 48. At least one computer-readable storage medium according to clause 46, wherein the overlapping predetermined amount of sequencing data is determined based on population data accessed by the detection subsystem.

[0188] 49. At least one computer-readable storage medium according to clause 46, wherein the predetermined amount of sequencing data that overlaps is determined based on user input.

[0189] 50. The at least one computer-readable storage medium of clause 46, wherein the computer-executable instructions are configured to cause the at least one processor to:

[0190] identifying, at the genotyping subsystem of the variant caller, the overlap in the sequencing data between the first segmented portion and the second segmented portion of the detectable region; and

[0191] Prior to performing the variant calling on the detectable region, removing the overlap in the sequencing data between the first segmented portion and the second segmented portion of the detectable region.

[0192] 51. The at least one computer-readable storage medium of clause 35, wherein the detectable area depth threshold is a first detectable area depth threshold, wherein the segmented portion is a first segmented portion, and wherein the computer-executable instructions are configured to cause the at least one processor to:

[0193] monitoring the depth of the plurality of reads at the calling subsystem of the variant caller;

[0194] When the depths of the plurality of read segments are below a second detectable region depth threshold, segmenting the detectable region; and

[0195] A second segmented portion of the detectable region is sent to the genotyping subsystem of the variant caller to make the variant call based on the second segmented portion.

[0196] 52. A computer-implemented method comprising:

[0197] Receiving sequencing data comprising a plurality of reads of a genomic sequence at a calling subsystem of a variant caller, wherein the calling subsystem of the variant caller is configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is below a depth threshold, and wherein the calling subsystem of the variant caller is configured to send at least a portion of the detectable region to a genotyping subsystem of the variant caller for variant calling of the detectable region;

[0198] monitoring memory used by the calling subsystem of the variant caller;

[0199] overflowing the detectable area to disk when the memory used by the calling subsystem of the variant caller is within a memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller; and

[0200] The overflowed detectable regions are streamed from the disk back to the memory used by the genotyping subsystem for processing.

[0201] 53. The computer-implemented method of clause 52, wherein spilling the detectable area to the disk comprises spilling a first portion of the detectable area to the disk and maintaining a second portion of the detectable area in the memory.

[0202] 54. A computer-implemented method according to clause 53, wherein the second portion of the detectable region is sent to the genotyping subsystem for processing via a pointer in the memory to maintain the second portion of the detectable region in the memory, and wherein the first portion of the detectable region is streamed from the disk.

[0203] 55. The computer-implemented method of clause 53, further comprising:

[0204] analyzing the overflowed detectable area streamed back from the disk;

[0205] Prior to streaming additional portions of the overflowed detectable region to the memory, one or more portions of the overflowed detectable region that will not be used for the variant calling are discarded from the memory.

[0206] 56. The computer-implemented method of clause 53, wherein the memory threshold is a first memory threshold associated with the detection subsystem, the method further comprising:

[0207] monitoring a second memory threshold associated with the genotyping subsystem; and preventing the second memory threshold from being exceeded while the overflowed detectable region is streamed from the disk.

[0208] 57. A sequencing system comprising:

[0209] Memory; and

[0210] at least one processor, the at least one processor being configured to:

[0211] Receiving sequencing data comprising a plurality of reads of a genomic sequence at a calling subsystem of a variant caller, wherein the calling subsystem of the variant caller is configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is below a depth threshold, and wherein the calling subsystem of the variant caller is configured to send at least a portion of the detectable region to a genotyping subsystem of the variant caller for variant calling of the detectable region;

[0212] monitoring the memory used by the calling subsystem of the variant caller;

[0213] overflowing the detectable area to disk when the memory used by the calling subsystem of the variant caller is within a memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller; and

[0214] The overflowed detectable regions are streamed from the disk back to the memory used by the genotyping subsystem for processing.

[0215] 58. A sequencing system according to claim 57, wherein the at least one processor is configured to overflow the detectable area to the disk by overflowing a first portion of the detectable area to the disk, and is further configured to maintain a second portion of the detectable area in the memory.

[0216] 59. A sequencing system according to claim 58, wherein the at least one processor is further configured to send the second portion of the detectable region to the genotyping subsystem for processing via a pointer in the memory to maintain the second portion of the detectable region in the memory, and wherein the at least one processor is further configured to stream the first portion of the detectable region from the disk.

[0217] 60. The sequencing system of clause 58, wherein the at least one processor is further configured to:

[0218] analyzing the overflowed detectable area streamed back from the disk;

[0219] Prior to streaming additional portions of the overflowed detectable region to the memory, one or more portions of the overflowed detectable region that will not be used for the variant calling are discarded from the memory.

[0220] 61. The sequencing system of clause 58, wherein the memory threshold is a first memory threshold associated with the detection subsystem, and the at least one processor is further configured to:

[0221] monitoring a second memory threshold associated with the genotyping subsystem; and preventing the second memory threshold from being exceeded while the overflowed detectable region is streamed from the disk.

[0222] 62. At least one computer-readable storage medium having stored thereon computer-executable instructions that, when executed by at least one processor, cause the at least one processor to:

[0223] Receiving sequencing data comprising a plurality of reads of a genomic sequence at a calling subsystem of a variant caller, wherein the calling subsystem of the variant caller is configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is below a depth threshold, and wherein the calling subsystem of the variant caller is configured to send at least a portion of the detectable region to a genotyping subsystem of the variant caller for variant calling of the detectable region;

[0224] monitoring memory used by the calling subsystem of the variant caller;

[0225] overflowing the detectable area to disk when the memory used by the calling subsystem of the variant caller is within a memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller; and

[0226] The overflowed detectable regions are streamed from the disk back to the memory used by the genotyping subsystem for processing.

[0227] 63. At least one computer-readable storage medium according to clause 62, wherein the computer-executable instructions are configured to cause at least one of: overflowing the detectable area to the disk by overflowing a first portion of the detectable area to the disk, and further configured to maintain a second portion of the detectable area in the memory.

[0228] 64. At least one computer-readable storage medium according to clause 63, wherein the computer-executable instructions are configured to cause the at least one processor to: send the second portion of the detectable region to the genotyping subsystem for processing via a pointer in the memory to maintain the second portion of the detectable region in the memory, and wherein the at least one processor is further configured to stream the first portion of the detectable region from the disk.

[0229] 65. The at least one computer-readable storage medium of clause 63, wherein the computer-executable instructions are configured to cause the at least one processor to:

[0230] analyzing the overflowed detectable area streamed back from the disk;

[0231] Prior to streaming additional portions of the overflowed detectable region to the memory, one or more portions of the overflowed detectable region that will not be used for the variant calling are discarded from the memory.

[0232] 66. The at least one computer-readable storage medium of clause 63, wherein the memory threshold is a first memory threshold associated with the detection subsystem, wherein the computer-executable instructions are configured to cause the at least one processor to:

[0233] monitoring a second memory threshold associated with the genotyping subsystem; and preventing the second memory threshold from being exceeded while the overflowed detectable region is streamed from the disk.

Claims

1. A computer-implemented method comprising: Receiving, at a calling subsystem of a variant caller, sequencing data comprising a plurality of reads of a genomic sequence, wherein the calling subsystem of the variant caller is configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is above a detectable region depth threshold, and wherein the calling subsystem of the variant caller is configured to send at least a portion of the detectable region to a genotyping subsystem of the variant caller for variant calling of the detectable region; monitoring memory used by the calling subsystem of the variant caller; When the memory used by the calling subsystem of the variant caller exceeds a memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller, segmenting the detectable region; as well as The segmented portions of the detectable regions are sent to the genotyping subsystem of the variant caller to make the variant calls based on the segmented portions.

2. A computer-implemented method according to claim 1, wherein sending the segmented portion of the detectable region to the genotyping subsystem increases the availability of the memory used by the calling subsystem.

3. The computer-implemented method of claim 1, wherein the memory threshold is a fixed threshold. The computer-implemented method of claim 1 , wherein the memory threshold is a dynamic threshold.

5. The computer-implemented method of claim 1 , further comprising: analyzing the sequencing data at the calling subsystem of the variant caller when the memory used by the calling subsystem of the variant caller is within the memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller; identifying variants or mutations in the sequencing data within a predetermined proximity of the identified segment; as well as After identifying the variant or mutation in the sequencing data, the segmenting of the detectable region is performed outside the predetermined proximity of the variant or mutation.

6. A computer-implemented method according to claim 5, wherein at least one of the variants or mutations or the predetermined proximity of the identified segmentation is determined based on population data accessed by the detection subsystem.

7. The computer-implemented method of claim 5, wherein the variant or mutation comprises an insertion or a deletion.

8. The computer-implemented method of claim 1 , further comprising: The buffered sequencing data is analyzed to identify locations of the segmentations of the detectable regions within the buffered sequencing data.

9. The computer-implemented method of claim 8, further comprising: identifying a portion of the buffered sequencing data having a read depth below a segmentation threshold; as well as The segmenting of the buffered sequencing data is performed at the identified portions having the read depth below the segmentation threshold.

10. The computer-implemented method of claim 1, wherein the detectable region is sent to the genotyping subsystem when the depth of the plurality of reads is below the detectable region depth threshold for detecting the detectable region.

11. The computer-implemented method of claim 1, wherein the segmented portion of the detectable area is the entirety of the detectable area currently in the memory used by the detection subsystem.

12. The computer-implemented method of claim 1 , wherein the segmented portion is a first segmented portion, the method further comprising: maintaining a predetermined amount of the sequencing data in the first segmented portion of the detectable region in the memory used by the calling subsystem of the variant caller; detecting a second segmented portion of the detectable area based on the detectable area depth threshold or the memory threshold; as well as The second segmented portion of the detectable region is sent to the genotyping subsystem of the variant caller to perform the variant calling based on the second segmented portion, wherein the second segmented portion includes an overlap of the sequencing data with the first segmented portion of the detectable region including the predetermined amount of sequencing data.

13. The computer-implemented method of claim 12, wherein the predetermined amount of sequencing data that overlaps is a predetermined number of bases.

14. A computer-implemented method according to claim 12, wherein the overlapping predetermined amount of sequencing data is determined based on population data accessed by the detection subsystem.

15. The computer-implemented method of claim 12, wherein the predetermined amount of sequencing data that overlaps is determined based on user input.

16. The computer-implemented method of claim 12, further comprising: identifying, at the genotyping subsystem of the variant caller, the overlap in the sequencing data between the first segmented portion and the second segmented portion of the detectable region; as well as Prior to performing the variant calling on the detectable region, removing the overlap in the sequencing data between the first segmented portion and the second segmented portion of the detectable region.

17. The computer-implemented method of claim 1, wherein the detectable region depth threshold is a first detectable region depth threshold, wherein the segmented portion is a first segmented portion, and wherein the method further comprises: monitoring the depth of the plurality of reads at the calling subsystem of the variant caller; When the depths of the plurality of read segments are below a second detectable region depth threshold, segmenting the detectable region; as well as A second segmented portion of the detectable region is sent to the genotyping subsystem of the variant caller to make the variant call based on the second segmented portion.

18. A computer-implemented method comprising: Receiving sequencing data comprising a plurality of reads of a genomic sequence at a calling subsystem of a variant caller, wherein the calling subsystem of the variant caller is configured to detect a detectable region of the sequencing data when a depth of the plurality of reads is below a depth threshold, and wherein the calling subsystem of the variant caller is configured to send at least a portion of the detectable region to a genotyping subsystem of the variant caller for variant calling of the detectable region; monitoring memory used by the calling subsystem of the variant caller; overflowing the callable area to disk when the memory used by the calling subsystem of the variant caller is within a memory threshold of the total amount of memory allocated to the calling subsystem of the variant caller; as well as The overflowed detectable regions are streamed from the disk back to the memory used by the genotyping subsystem for processing.

19. The computer-implemented method of claim 18, wherein spilling the detectable area to the disk comprises spilling a first portion of the detectable area to the disk and maintaining a second portion of the detectable area in the memory.

20. The computer-implemented method of claim 19, wherein the second portion of the detectable region is sent to the genotyping subsystem for processing via a pointer in the memory to maintain the second portion of the detectable region in the memory, and wherein the first portion of the detectable region is streamed from the disk.

21. The computer-implemented method of claim 19, further comprising: analyzing the overflowed detectable area streamed back from the disk; Prior to streaming additional portions of the overflowed detectable region to the memory, one or more portions of the overflowed detectable region that will not be used for the variant calling are discarded from the memory.

22. The computer-implemented method of claim 19, wherein the memory threshold is a first memory threshold associated with the detection subsystem, the method further comprising: monitoring a second memory threshold associated with the genotyping subsystem; as well as The second memory threshold is prevented from being exceeded while the overflowed detectable area is streamed from the disk.

Images