include/unpack.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	unpack_initialize ()
unpackRegion *	unpack_selectRegion (struct unpackRegion *unpackRegions, uint4 numUnpackRegions, uint4 subjectOffset)
void	unpack_extendRegionStart (int4 position, struct unpackRegion *unpackRegion)
void	unpack_extendRegionEnd (int4 position, struct unpackRegion *unpackRegion)
int4	unpack_loadSubject (struct PSSMatrix PSSMatrix, struct alignment *alignment)
void	unpack_unpackSubject (struct PSSMatrix PSSMatrix, struct alignment *alignment)
int	unpack_entireSubjectUnpacked (struct alignment *alignment)
void	unpack_free ()

---

Function Documentation

int unpack_entireSubjectUnpacked

(

struct alignment *

alignment

)

Definition at line 511 of file unpack.c.

References unpackRegion::endOffset, unpackRegion::startOffset, alignment::subjectLength, and alignment::unpackRegions.

Referenced by alignments_getTracebacks().

{
        if (alignment->unpackRegions[0].startOffset == 0 &&
        alignment->unpackRegions[0].endOffset == alignment->subjectLength)
                return 1;
    else
        return 0;
}

Here is the caller graph for this function:

void unpack_extendRegionEnd	(	int4	position,
		struct unpackRegion *	unpackRegion
	)

Definition at line 106 of file unpack.c.

References constants_unpackRegionExtend, encoding_byteUnpackRegion(), unpackRegion::endOffset, global_realloc(), int4, unpackRegion::startOffset, unpackRegion::subject, unpackRegion::subjectLength, and unpackRegion::unpackedSubject.

Referenced by gappedExtension_dpAfterSeed().

{
        unsigned char* newUnpackedSubject;
    int4 newRegionStart, newRegionEnd;

//    printf("pos=%d region=%d,%d subjectLength=%d\n", position, unpackRegion->startOffset,
//           unpackRegion->endOffset, unpackRegion->subjectLength); fflush(stdout);

        if (position > unpackRegion->endOffset)
    {
        // Extend the region end
        newRegionStart = unpackRegion->startOffset;
        newRegionEnd = unpackRegion->endOffset + constants_unpackRegionExtend;
        if (newRegionEnd > unpackRegion->subjectLength) newRegionEnd = unpackRegion->subjectLength;

        // Realloc memory for the new region
                unpackRegion->unpackedSubject += unpackRegion->startOffset;
                newUnpackedSubject = (unsigned char*)global_realloc(unpackRegion->unpackedSubject,
                              sizeof(char) * (newRegionEnd - newRegionStart));
                newUnpackedSubject -= newRegionStart;

        // Round old end
        unpackRegion->endOffset = (unpackRegion->endOffset / 4) * 4;

                // Unpack the new part of the region
                encoding_byteUnpackRegion(newUnpackedSubject + unpackRegion->endOffset,
                unpackRegion->subject + (unpackRegion->endOffset / 4),
            newRegionEnd - unpackRegion->endOffset);

                unpackRegion->unpackedSubject = newUnpackedSubject;

        unpackRegion->endOffset = newRegionEnd;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void unpack_extendRegionStart	(	int4	position,
		struct unpackRegion *	unpackRegion
	)

Definition at line 67 of file unpack.c.

References constants_unpackRegionExtend, encoding_byteUnpackRegion(), unpackRegion::endOffset, global_malloc(), int4, unpackRegion::startOffset, unpackRegion::subject, and unpackRegion::unpackedSubject.

Referenced by gappedExtension_dpBeforeSeed().

{
        unsigned char* newUnpackedSubject;
    int4 newRegionStart, newRegionEnd;

        if (position < unpackRegion->startOffset)
    {
        // Extend the region start
        newRegionStart = unpackRegion->startOffset - constants_unpackRegionExtend;
        if (newRegionStart < 0) newRegionStart = 0;
        newRegionEnd = unpackRegion->endOffset;

        // Make start of region a multiple of 4
        newRegionStart = (newRegionStart / 4) * 4;

        // Declare memory for the new region
        newUnpackedSubject = (unsigned char*)global_malloc(sizeof(char) * (newRegionEnd - newRegionStart));
                newUnpackedSubject -= newRegionStart;

        // Copy unpacked subject from old region to new
        memcpy(newUnpackedSubject + unpackRegion->startOffset,
               unpackRegion->unpackedSubject + unpackRegion->startOffset,
               sizeof(char) * (unpackRegion->endOffset - unpackRegion->startOffset));

                // Free old subject
                unpackRegion->unpackedSubject += unpackRegion->startOffset;
        free(unpackRegion->unpackedSubject);

                // Unpack the new part of the region
                encoding_byteUnpackRegion(newUnpackedSubject + newRegionStart, unpackRegion->subject + (newRegionStart / 4),
                                  unpackRegion->startOffset - newRegionStart);

                unpackRegion->unpackedSubject = newUnpackedSubject;

        unpackRegion->startOffset = newRegionStart;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void unpack_free

(

)

Definition at line 521 of file unpack.c.

References encoding_alphabetType, encoding_nucleotide, memBlocks_free(), memBlocks_getCurrent(), memBlocks_resetCurrent(), parameters_ssearch, unpackRegion::startOffset, unpackRegion::subject, unpack_subjectRegions, unpack_unpackRegions, and unpackRegion::unpackedSubject.

Referenced by alignments_free().

{
        struct unpackRegion* region;

    // For each unpack region
        if (!parameters_ssearch && encoding_alphabetType == encoding_nucleotide)
        {
        memBlocks_resetCurrent(unpack_unpackRegions);
        while ((region = memBlocks_getCurrent(unpack_unpackRegions)) != NULL)
        {
            // Free the unpacked sequence
            free(region->unpackedSubject + region->startOffset);
        }
        }

    // For each copied subject region
        memBlocks_resetCurrent(unpack_subjectRegions);
        while ((region = memBlocks_getCurrent(unpack_subjectRegions)) != NULL)
    {
                // Free the subject
        free(region->subject + region->startOffset / 4);
    }

    memBlocks_free(unpack_unpackRegions);
    memBlocks_free(unpack_subjectRegions);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void unpack_initialize

(

)

Definition at line 14 of file unpack.c.

References constants_initialAllocUnpackRegions, memBlocks_initialize(), unpack_subjectRegions, and unpack_unpackRegions.

Referenced by alignments_initialize().

{
        unpack_unpackRegions = memBlocks_initialize(sizeof(struct unpackRegion),
                           constants_initialAllocUnpackRegions);

        unpack_subjectRegions = memBlocks_initialize(sizeof(struct unpackRegion),
                            constants_initialAllocUnpackRegions);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int4 unpack_loadSubject	(	struct PSSMatrix	PSSMatrix,
		struct alignment *	alignment
	)

Definition at line 291 of file unpack.c.

References blast_totalCopied, alignment::descriptionLocation, alignment::edits, alignment::encodedLength, encoding_alphabetType, encoding_protein, global_malloc(), alignment::inMemorySubject, int4, memBlocks_getLastEntry(), alignment::numUnpackRegions, parameters_verboseDloc, alignment::subject, unpackRegion::subject, alignment::subjectLength, uint4, unpack_getRegions(), unpack_subjectRegions, and alignment::unpackRegions.

Referenced by alignments_loadSubjectsIntoMemory().

{
        uint4 totalCopied = 0;
        unsigned char *subject, *edits, *endEdits;
    struct unpackRegion *firstRegion = NULL, *lastRegion, *currentRegion;
    int4 numRegions, regionStart, regionEnd;

    // If protein search
    if (encoding_alphabetType == encoding_protein)
    {
        // Make copy of sequence
        subject = (unsigned char*)global_malloc(sizeof(unsigned char) * alignment->encodedLength);
        subject++;
        memcpy(subject - 1, alignment->subject - 1, alignment->encodedLength);
        alignment->subject = subject;

        blast_totalCopied += alignment->encodedLength;
    }
    // If a nucleotide search
    else
    {
                // Get a list of regions to copy
        numRegions = unpack_getRegions(PSSMatrix, alignment, 1, unpack_subjectRegions);
        lastRegion = memBlocks_getLastEntry(unpack_subjectRegions);
        lastRegion++;
        firstRegion = lastRegion - numRegions;

        #ifdef VERBOSE
        if (parameters_verboseDloc == alignment->descriptionLocation)
        {
                printf("%d regions for subject\n", lastRegion - firstRegion); fflush(stdout);
                }
        #endif

        // Copy each region into memory
        currentRegion = firstRegion;
        while (currentRegion < lastRegion)
        {
            #ifdef VERBOSE
            if (parameters_verboseDloc == alignment->descriptionLocation)
            {
                printf("Load region %d to %d into memory\n", currentRegion->startOffset,
                       currentRegion->endOffset); fflush(stdout);
                fflush(stdout);
            }
            #endif

            regionStart = currentRegion->startOffset / 4;
            regionEnd = (currentRegion->endOffset + 3) / 4;

            currentRegion->unpackedSubject = NULL;
                        currentRegion->subject = (unsigned char*)global_malloc(sizeof(unsigned char)
                                                   * (regionEnd - regionStart));

            totalCopied += regionEnd - regionStart;
                        memcpy(currentRegion->subject, alignment->subject + regionStart, regionEnd - regionStart);
                        currentRegion->subject -= regionStart;
                        currentRegion->subjectLength = alignment->subjectLength;

                blast_totalCopied += (regionEnd - regionStart);

            currentRegion++;
                }

        // Store new alignment regions
        alignment->unpackRegions = firstRegion;
        alignment->numUnpackRegions = lastRegion - firstRegion;

        // If there are edits for this subject
        if (alignment->edits != NULL)
        {
            edits = alignment->edits;
            endEdits = alignment->subject + alignment->encodedLength;

            // Make an in-memory copy of them
            alignment->edits = (unsigned char*)malloc(sizeof(char) * (endEdits - edits));
            memcpy(alignment->edits, edits, endEdits - edits);
        }

        alignment->subject = NULL;
    }

    alignment->inMemorySubject = 1;

    return totalCopied;

}

Here is the call graph for this function:

Here is the caller graph for this function:

struct unpackRegion* unpack_selectRegion	(	struct unpackRegion *	unpackRegions,
		uint4	numUnpackRegions,
		uint4	subjectOffset
	)			[read]

Definition at line 46 of file unpack.c.

References unpackRegion::endOffset, and unpackRegion::startOffset.

Referenced by alignments_getTracebacks(), alignments_selectRegion(), print_gappedAlignmentsFull(), and unpack_unpackSubject().

{
    // For each region
        while (numUnpackRegions > 0)
    {
        if (unpackRegions->startOffset <= subjectOffset && unpackRegions->endOffset > subjectOffset)
        {
                        // Return it if seed falls within its range
            return unpackRegions;
        }

        unpackRegions++;
                numUnpackRegions--;
    }

    fprintf(stderr, "Error unpacking subject and performing gapped alignment\n");
    exit(-1);
}

Here is the caller graph for this function:

void unpack_unpackSubject	(	struct PSSMatrix	PSSMatrix,
		struct alignment *	alignment
	)

Definition at line 380 of file unpack.c.

References blast_totalUnpacked, alignment::descriptionLocation, alignment::edits, alignment::encodedLength, encoding_alphabetType, encoding_byteUnpackRegion(), encoding_protein, unpackRegion::endOffset, global_malloc(), int4, memBlocks_getLastEntry(), memBlocks_newEntry(), alignment::numUnpackRegions, parameters_ssearch, parameters_verboseDloc, unpackRegion::startOffset, alignment::subject, unpackRegion::subject, unpackRegion::subjectLength, alignment::subjectLength, uint4, unpack_compareUnpackRegions(), unpack_getRegions(), unpack_selectRegion(), unpack_unpackRegions, unpackRegion::unpackedSubject, alignment::unpackRegions, and vbyte_getVbyte.

Referenced by alignments_getTracebacks().

{
    unsigned char *subject, *unpackedSubject, wildcard, *edits, *endEdits;
    uint4 wildcardPosition;
    struct unpackRegion *firstRegion = NULL, *lastRegion, *currentRegion, *unpackRegion;
    int4 regionStart, regionEnd, numRegions;

    // No need to unpack a protein subject, or already unpacked nucleotide subject
    if (parameters_ssearch || encoding_alphabetType == encoding_protein)
    {
        // Just create a single region covering the entire sequence
        firstRegion = memBlocks_newEntry(unpack_unpackRegions);
        firstRegion->startOffset = 0;
        firstRegion->endOffset = alignment->subjectLength;
        firstRegion->subject = alignment->subject;
        firstRegion->unpackedSubject = alignment->subject;
        firstRegion->subjectLength = alignment->subjectLength;
        alignment->unpackRegions = firstRegion;
        alignment->numUnpackRegions = 1;
        return;
    }

    // Get the subject regions for this alignment
    numRegions = unpack_getRegions(PSSMatrix, alignment, 0, unpack_unpackRegions);
    lastRegion = memBlocks_getLastEntry(unpack_unpackRegions);
    lastRegion++;
    firstRegion = lastRegion - numRegions;

    // Sort the regions in order of start position
        qsort(firstRegion, lastRegion - firstRegion,
          sizeof(struct unpackRegion), unpack_compareUnpackRegions);

    // Unpack each region
    currentRegion = firstRegion;
    while (currentRegion < lastRegion)
    {
        regionEnd = currentRegion->endOffset;
        regionStart = currentRegion->startOffset;

        #ifdef VERBOSE
        if (parameters_verboseDloc == alignment->descriptionLocation)
                {
                printf("Unpack subject region %d to %d (length=%d)\n", regionStart, regionEnd,
                   alignment->subjectLength);
            fflush(stdout);
        }
                #endif

                // Get the subject region to be unpacked
        if (alignment->unpackRegions == NULL)
        {
                subject = alignment->subject;
        }
        else
        {
            unpackRegion = unpack_selectRegion(alignment->unpackRegions, alignment->numUnpackRegions,
                                               regionStart);
                        subject = unpackRegion->subject;
        }

                // Declare memory for the region
        unpackedSubject = (unsigned char*)global_malloc(sizeof(char) * (regionEnd - regionStart));

                // Unpack the region of interest
        encoding_byteUnpackRegion(unpackedSubject, subject + (regionStart / 4),
                                  regionEnd - regionStart);
        unpackedSubject -= regionStart;
                currentRegion->unpackedSubject = unpackedSubject;

        currentRegion->subject = subject;
        currentRegion->subjectLength = alignment->subjectLength;

        blast_totalUnpacked += (regionEnd - regionStart);

        currentRegion++;
    }

        currentRegion = firstRegion;

        // Get wildcard edits for the sequence
        edits = alignment->edits;
        endEdits = alignment->edits + alignment->encodedLength - ((alignment->subjectLength + 3) / 4);

    // If there are edits
    if (edits < endEdits)
    {
        // Read first wildcard
        wildcard = *edits;
        edits++;

        // Read its position
        vbyte_getVbyte(edits, &wildcardPosition);

        // For each region in order of position in the subject
        while (currentRegion < lastRegion)
        {
            // Skip past edits that are before current region
            while (edits < endEdits && wildcardPosition < currentRegion->startOffset)
            {
                // Read wildcard
                wildcard = *edits;
                edits++;

                // Read its position
                vbyte_getVbyte(edits, &wildcardPosition);
            }

            // Process edits that are in the current region
            while (edits < endEdits && wildcardPosition < currentRegion->endOffset)
            {
                // Insert wildcard into sequence
                currentRegion->unpackedSubject[wildcardPosition] = wildcard;

                // Read next wildcard
                wildcard = *edits;
                edits++;

                // Read its position
                vbyte_getVbyte(edits, &wildcardPosition);
            }

            // Advance to the next region
            currentRegion++;
        }
        }

    alignment->unpackRegions = firstRegion;
    alignment->numUnpackRegions = lastRegion - firstRegion;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---