Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

moved memory allocations up #4

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

moved memory allocations up #4

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
96 changes: 59 additions & 37 deletions src/gssw.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -131,25 +131,21 @@ gssw_alignment_end* gssw_sw_sse2_byte (const int8_t* ref,
uint8_t bias, /* Shift 0 point to a positive value. */
int32_t maskLen,
gssw_align* alignment, /* to save seed and matrix */
const gssw_seed* seed) { /* to seed the alignment */
const gssw_seed* seed, /* to seed the alignment */
__m128i *pvHStore, /* Moved memory allocations up */
__m128i *pvHLoad,
__m128i *pvHmax,
__m128i *pvE) {

uint8_t max = 0; /* the max alignment score */
int32_t end_read = readLen - 1;
int32_t end_ref = -1; /* 0_based best alignment ending point; Initialized as isn't aligned -1. */
int32_t segLen = (readLen + 15) / 16; /* number of segment */

/* Initialize buffers used in alignment */
__m128i* pvHStore;
__m128i* pvHLoad;
__m128i* pvHmax;
__m128i* pvE;

uint8_t* mH; // used to save matrix for external traceback
/* Note use of aligned memory. Return value of 0 means success for posix_memalign. */
if (!(!posix_memalign((void**)&pvHStore, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&pvHLoad, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&pvHmax, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&pvE, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&alignment->seed.pvE, sizeof(__m128i), segLen*sizeof(__m128i)) &&
if (!(!posix_memalign((void**)&alignment->seed.pvE, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&alignment->seed.pvHStore, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&mH, sizeof(__m128i), segLen*refLen*sizeof(__m128i)))) {
fprintf(stderr, "error:[gssw] Could not allocate memory required for alignment buffers.\n");
Expand Down Expand Up @@ -366,10 +362,10 @@ gssw_alignment_end* gssw_sw_sse2_byte (const int8_t* ref,

//fprintf(stderr, "%p %p %p %p %p %p\n", *pmH, mH, pvHmax, pvE, pvHLoad, pvHStore);

free(pvE);
free(pvHmax);
free(pvHLoad);
free(pvHStore);
//free(pvE);
//free(pvHmax);
//free(pvHLoad);
//free(pvHStore);

/* Find the most possible 2nd best alignment. */
gssw_alignment_end* bests = (gssw_alignment_end*) calloc(2, sizeof(gssw_alignment_end));
Expand Down Expand Up @@ -415,27 +411,22 @@ gssw_alignment_end* gssw_sw_sse2_word (const int8_t* ref,
uint16_t terminate,
int32_t maskLen,
gssw_align* alignment, /* to save seed and matrix */
const gssw_seed* seed) { /* to seed the alignment */
const gssw_seed* seed,
__m128i *pvHStore,
__m128i *pvHLoad,
__m128i *pvHmax,
__m128i *pvE) { /* to seed the alignment */


uint16_t max = 0; /* the max alignment score */
int32_t end_read = readLen - 1;
int32_t end_ref = 0; /* 1_based best alignment ending point; Initialized as isn't aligned - 0. */
int32_t segLen = (readLen + 7) / 8; /* number of segment */

/* Initialize buffers used in alignment */
__m128i* pvHStore;
__m128i* pvHLoad;
__m128i* pvHmax;
__m128i* pvE;
uint16_t* mH; // used to save matrix for external traceback
/* Note use of aligned memory */

if (!(!posix_memalign((void**)&pvHStore, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&pvHLoad, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&pvHmax, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&pvE, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&alignment->seed.pvE, sizeof(__m128i), segLen*sizeof(__m128i)) &&
if (!(!posix_memalign((void**)&alignment->seed.pvE, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&alignment->seed.pvHStore, sizeof(__m128i), segLen*sizeof(__m128i)) &&
!posix_memalign((void**)&mH, sizeof(__m128i), segLen*refLen*sizeof(__m128i)))) {
fprintf(stderr, "error:[gssw] Could not allocate memory required for alignment buffers.\n");
Expand Down Expand Up @@ -594,10 +585,6 @@ gssw_alignment_end* gssw_sw_sse2_word (const int8_t* ref,
}
}

free(pvE);
free(pvHmax);
free(pvHLoad);
free(pvHStore);

/* Find the most possible 2nd best alignment. */
gssw_alignment_end* bests = (gssw_alignment_end*) calloc(2, sizeof(gssw_alignment_end));
Expand Down Expand Up @@ -662,27 +649,41 @@ gssw_align* gssw_fill (const gssw_profile* prof,
int32_t readLen = prof->readLen;
gssw_align* alignment = gssw_align_create();

__m128i *pvHStore;
__m128i *pvHLoad;
__m128i *pvHmax;
__m128i *pvE;
int32_t segLen = (prof->readLen + 15) / 16;

if (!(!posix_memalign((void **) &pvHStore, sizeof(__m128i), segLen * sizeof(__m128i)) &&
!posix_memalign((void **) &pvHLoad, sizeof(__m128i), segLen * sizeof(__m128i)) &&
!posix_memalign((void **) &pvHmax, sizeof(__m128i), segLen * sizeof(__m128i)) &&
!posix_memalign((void **) &pvE, sizeof(__m128i), segLen * sizeof(__m128i)))) {
fprintf(stderr, "Error allocating memory in graph_fill.\n");
exit(1);
}

if (maskLen < 15) {
fprintf(stderr, "When maskLen < 15, the function ssw_align doesn't return 2nd best alignment information.\n");
}

// Find the alignment scores and ending positions
if (prof->profile_byte) {
bests = gssw_sw_sse2_byte(ref, 0, refLen, readLen, weight_gapO, weight_gapE, prof->profile_byte, -1, prof->bias, maskLen,
alignment, seed);
alignment, seed, pvHStore, pvHLoad, pvHmax, pvE);

if (prof->profile_word && bests[0].score == 255) {
free(bests);
gssw_align_clear_matrix_and_seed(alignment);
bests = gssw_sw_sse2_word(ref, 0, refLen, readLen, weight_gapO, weight_gapE, prof->profile_byte, -1, maskLen,
alignment, seed);
alignment, seed, pvHStore, pvHLoad, pvHmax, pvE);
} else if (bests[0].score == 255) {
fprintf(stderr, "Please set 2 to the score_size parameter of the function ssw_init, otherwise the alignment results will be incorrect.\n");
return 0;
}
} else if (prof->profile_word) {
bests = gssw_sw_sse2_word(ref, 0, refLen, readLen, weight_gapO, weight_gapE, prof->profile_word, -1, maskLen,
alignment, seed);
alignment, seed, pvHStore, pvHLoad, pvHmax, pvE);
} else {
fprintf(stderr, "Please call the function ssw_init before ssw_align.\n");
return 0;
Expand Down Expand Up @@ -1561,6 +1562,20 @@ gssw_graph_fill (gssw_graph* graph,
gssw_seed* seed = NULL;
uint16_t max_score = 0;

__m128i *pvHStore;
__m128i *pvHLoad;
__m128i *pvHmax;
__m128i *pvE;
int32_t segLen = (prof->readLen + 15) / 16;

if (!(!posix_memalign((void **) &pvHStore, sizeof(__m128i), segLen * sizeof(__m128i)) &&
!posix_memalign((void **) &pvHLoad, sizeof(__m128i), segLen * sizeof(__m128i)) &&
!posix_memalign((void **) &pvHmax, sizeof(__m128i), segLen * sizeof(__m128i)) &&
!posix_memalign((void **) &pvE, sizeof(__m128i), segLen * sizeof(__m128i)))) {
fprintf(stderr, "Error allocating memory in graph_fill.\n");
exit(1);
}

// for each node, from start to finish in the partial order (which should be sorted topologically)
// generate a seed from input nodes or use existing (e.g. for subgraph traversal here)
uint32_t i;
Expand All @@ -1573,7 +1588,8 @@ gssw_graph_fill (gssw_graph* graph,
} else {
seed = gssw_create_seed_word(prof->readLen, n->prev, n->count_prev);
}
gssw_node* filled_node = gssw_node_fill(n, prof, weight_gapO, weight_gapE, maskLen, seed);
gssw_node* filled_node = gssw_node_fill(n, prof, weight_gapO, weight_gapE, maskLen, seed,
pvHStore, pvHLoad, pvHmax, pvE);
gssw_seed_destroy(seed); seed = NULL; // cleanup seed
// test if we have exceeded the score dynamic range
if (prof->profile_byte && !filled_node) {
Expand Down Expand Up @@ -1606,7 +1622,11 @@ gssw_node_fill (gssw_node* node,
const uint8_t weight_gapO,
const uint8_t weight_gapE,
const int32_t maskLen,
const gssw_seed* seed) {
const gssw_seed* seed,
__m128i *pvHStore,
__m128i *pvHLoad,
__m128i *pvHmax,
__m128i *pvE) {

gssw_alignment_end* bests = NULL;
int32_t readLen = prof->readLen;
Expand All @@ -1632,14 +1652,16 @@ gssw_node_fill (gssw_node* node,

// Find the alignment scores and ending positions
if (prof->profile_byte) {
bests = gssw_sw_sse2_byte((const int8_t*)node->num, 0, node->len, readLen, weight_gapO, weight_gapE, prof->profile_byte, -1, prof->bias, maskLen, alignment, seed);
bests = gssw_sw_sse2_byte((const int8_t*)node->num, 0, node->len, readLen, weight_gapO, weight_gapE, prof->profile_byte, -1, prof->bias, maskLen, alignment, seed,
pvHStore, pvHLoad, pvHmax, pvE);
if (bests[0].score == 255) {
free(bests);
gssw_align_clear_matrix_and_seed(alignment);
return 0; // re-run from external context
}
} else if (prof->profile_word) {
bests = gssw_sw_sse2_word((const int8_t*)node->num, 0, node->len, readLen, weight_gapO, weight_gapE, prof->profile_word, -1, maskLen, alignment, seed);
bests = gssw_sw_sse2_word((const int8_t*)node->num, 0, node->len, readLen, weight_gapO, weight_gapE, prof->profile_word, -1, maskLen, alignment, seed,
pvHStore, pvHLoad, pvHmax, pvE);
} else {
fprintf(stderr, "Please call the function ssw_init before ssw_align.\n");
return 0;
Expand Down
6 changes: 5 additions & 1 deletion src/gssw.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -373,7 +373,11 @@ gssw_node_fill (gssw_node* node,
const uint8_t weight_gapO,
const uint8_t weight_gapE,
const int32_t maskLen,
const gssw_seed* seed);
const gssw_seed* seed,
__m128i *pvHStore,
__m128i *pvHLoad,
__m128i *pvHmax,
__m128i *pvE);

gssw_graph*
gssw_graph_fill (gssw_graph* graph,
Expand Down