genetics::GeneManager Struct Reference

Manages efficient loading of multiple genetic sequences from a combined file. More...

Classes
struct	GeneInfo
	Structure to track information about a gene in the combined file. More...

Public Member Functions
	GeneManager (const std::string &path)
	Constructs a GeneManager for accessing genes in the specified path.
	~GeneManager ()
	Destructor for GeneManager.
std::vector< Gene >	all_genes () const
	Retrieves all genes from the combined file.
std::vector< Gene >	get_random_genes (size_t count) const
	Retrieves a random subset of genes from the combined file.

Private Member Functions
void	save_sizes ()
	Saves the size information of genes to a companion file.
void	load_sizes ()
	Loads gene size information from the companion file.

Private Attributes
std::string	m_path
	Path to the combined binary file.
std::ifstream	m_file
	File stream for reading gene data (mutable to allow const methods to read)
std::vector< GeneInfo >	m_gene_infos
	Index of all genes in the combined file.

Detailed Description

Manages efficient loading of multiple genetic sequences from a combined file.

This class provides utilities for loading genes from a combined binary file created by combine_dna_bin_files(). It maintains an index of genes in the file for fast random access without loading the entire dataset into memory at once.

See also

combine_dna_bin_files

Definition at line 225 of file genetics.cuh.

Constructor & Destructor Documentation

GeneManager()

GeneManager::GeneManager

(

const std::string &

path

)

Constructs a GeneManager for accessing genes in the specified path.

Parameters

path	Path to the combined binary file containing genetic sequences.

Exceptions

std::runtime_error

If the file cannot be opened or is improperly formatted.

Definition at line 411 of file genetics.cu.

                                              : m_path(path)
{
    // Open the combined binary file
    m_file.open(path + DNA_BIN_COMBINED_EXTENSION, std::ios::binary);
    if (!m_file.is_open())
    {
        throw std::invalid_argument("File not found");
    }
 
    WallTimer timer;
    timer.start("Loading names and positions");
 
    // Read the number of genes stored in the file
    size_t num_names;
    m_file.read(reinterpret_cast<char*>(&num_names), sizeof(num_names));
 
    // Reserve space for all gene metadata
    m_gene_infos.reserve(num_names);
    // Note: Previous implementation stored names and positions in separate vectors
    // m_names.reserve(num_names);
    // m_positions.reserve(num_names);
 
    // Parse the gene metadata header
    for (size_t i = 0; i < num_names; ++i)
    {
        // Read null-terminated gene name
        std::string name;
        char c;
        while (m_file.read(&c, 1) && c != '\0')
        {
            name.push_back(c);
        }
 
        // Read the position where this gene's data starts in the file
        std::streampos position;
        m_file.read(reinterpret_cast<char*>(&position), sizeof(position));
        
        // Store the metadata (size will be loaded or determined later)
        m_gene_infos.push_back({ name, position, 0 });
    }
 
    timer.print();
 
    // Load or create the size information for each gene
    if (std::filesystem::exists(path + DNA_BIN_SIZES_EXTENSION))
    {
        // If size cache already exists, load it
        load_sizes();
    }
    else
    {
        // Otherwise, calculate and save sizes
        save_sizes();
    }
 
    // Sort genes by their size for optimized access patterns
    timer.start("Sorting by size");
    std::sort(m_gene_infos.begin(), m_gene_infos.end(), [](const GeneInfo& a, const GeneInfo& b) { return a.size < b.size; });
    timer.print();
}

~GeneManager()

GeneManager::~GeneManager

(

)

Destructor for GeneManager.

Closes any open file streams.

Definition at line 522 of file genetics.cu.

{
    m_file.close();
}

Member Function Documentation

all_genes()

std::vector< Gene > GeneManager::all_genes

(

)

const

Retrieves all genes from the combined file.

Returns

std::vector<Gene> A vector containing all genetic sequences from the file.

Definition at line 527 of file genetics.cu.

{
    std::vector<Gene> genes;
    // Iterate through all gene infos and load each gene from the combined file
    for (const auto& info : m_gene_infos)
    {
        // Position file pointer at the start of this gene's data
        m_file.seekg(info.position);
        
        // Load the gene from the current file position and add to result vector
        genes.emplace_back(Gene::from_file(m_file));
    }
 
    return genes;
}

get_random_genes()

std::vector< Gene > GeneManager::get_random_genes

(

size_t

count

)

const

Retrieves a random subset of genes from the combined file.

Parameters

count

The number of random genes to retrieve.

Returns

std::vector<Gene> A vector containing the randomly selected genetic sequences.

Definition at line 543 of file genetics.cu.

{
    // Initialize static random number generator for efficient repeated calls
    static std::random_device rd;
    static std::mt19937 gen(rd());
    static std::uniform_int_distribution<size_t> dist(0, m_gene_infos.size() - 1);
 
    // Use a set to ensure we don't select the same gene twice
    // Store positions rather than indices to directly access the file
    std::unordered_set<size_t> positions;
 
    // Select random genes until we have the requested count
    while (positions.size() < count)
    {
        positions.insert(m_gene_infos[dist(gen)].position);
    }
 
    std::vector<Gene> genes;
 
    // Load each selected gene from its file position
    for (const auto& position : positions)
    {
        // Position file pointer at the gene's data
        m_file.seekg(position);
        
        // Load the gene and add to result vector
        genes.emplace_back(Gene::from_file(m_file));
    }
 
    return genes;
}

load_sizes()

void GeneManager::load_sizes ( )

private

Loads gene size information from the companion file.

Reads the .sizes file to populate the m_gene_infos vector with metadata about each gene in the combined binary file.

Exceptions

std::runtime_error

If the sizes file cannot be opened or is corrupted.

Definition at line 500 of file genetics.cu.

{
    WallTimer timer;
    timer.start("Loading sizes");
 
    // Open the pre-computed sizes file which contains size information for each gene
    std::ifstream sizes_file(m_path + DNA_BIN_SIZES_EXTENSION, std::ios::binary);
    if (!sizes_file.is_open())
    {
        throw std::invalid_argument("File not found");
    }
 
    // Read size for each gene in the same order as the gene infos
    for (auto& info : m_gene_infos)
    {
        // Load the pre-computed size directly into the gene info structure
        sizes_file.read(reinterpret_cast<char*>(&info.size), sizeof(info.size));
    }
 
    timer.print();
}

save_sizes()

void GeneManager::save_sizes ( )

private

Saves the size information of genes to a companion file.

Creates a .sizes file alongside the combined binary file that stores metadata about each gene for efficient future loading.

Definition at line 472 of file genetics.cu.

{
    WallTimer timer;
    timer.start("Loading & saving sizes");
 
    // Create a companion file to store size information for quick loading in future
    std::ofstream sizes_file(m_path + DNA_BIN_SIZES_EXTENSION, std::ios::binary);
    if (!sizes_file.is_open())
    {
        throw std::invalid_argument("File not found");
    }
 
    // For each gene, read its size from the combined file and save to the sizes file
    for (auto& info : m_gene_infos)
    {
        // Navigate to where this gene's data begins
        m_file.seekg(info.position);
        
        // Read the size value from the gene data header
        m_file.read(reinterpret_cast<char*>(&info.size), sizeof(info.size));
        
        // Write the size to the companion file for future quick loading
        sizes_file.write(reinterpret_cast<const char*>(&info.size), sizeof(info.size));
    }
 
    timer.print();
}

Member Data Documentation

m_file

std::ifstream genetics::GeneManager::m_file

mutableprivate

File stream for reading gene data (mutable to allow const methods to read)

Definition at line 267 of file genetics.cuh.

m_gene_infos

std::vector<GeneInfo> genetics::GeneManager::m_gene_infos

private

Index of all genes in the combined file.

Definition at line 268 of file genetics.cuh.

m_path

std::string genetics::GeneManager::m_path

private

Path to the combined binary file.

Definition at line 266 of file genetics.cuh.

---

The documentation for this struct was generated from the following files:

• src/genetics.cuh
• src/genetics.cu