/* set_row_layout()
*
* Determines the size of the a,b,c regions ("all", "between",
* "checkpointed") of rows in the DP matrix.
*
* Caller must have already set <ox->allocW> and <ox->R0>; they are
* needed here.
*
* Upon return, we've set the R{0abc} and L{abc} fields in the <ox>
* structure.
*
* <maxR> is the maximum number of rows the caller *wants* to use,
* either because a <ramlimit>'ed allocation fits that number of rows,
* or because an existing matrix has that number of valid rows. We
* will exceed this for one comparison if absolutely necessary, but
* the next <_Reuse()> call will bring the allocation back down.
*
* So there's three possibilities:
* 1. A full matrix fits into our recommended max memory use.
* 2. A checkpointed matrix fits into our recommended memory.
* Make as much of the matrix uncheckpointed as we can,
* using every row in maxR.
* 3. We can't satisfy the recommended max memory, even fully
* checkpointed. Make a fully checkpointed matrix, in which
* R0+Ra+Rb+Rc will exceed maxR, and caller will have to
* allocate ("redlined").
*/
static void
set_row_layout(P7_CHECKPTMX *ox, int allocL, int maxR)
{
double Rbc = minimum_rows(allocL);
int minR_chk = ox->R0 + (int) ceil(Rbc); /* min # rows we need for checkpointing */
int minR_all = ox->R0 + allocL; /* min # rows we need for full matrix */
if (minR_all <= maxR) set_full (ox, allocL);
else if (minR_chk <= maxR) set_checkpointed(ox, allocL, maxR);
else set_redlined (ox, allocL, Rbc);
}
static void
create()
{
::create();
set_name("clausthaler");
set_short("a bottle of clausthaler");
set_drinking_mess(" pours down a bottle of clausthaler.\n");
set_drinker_mess("Ach, sehr gut.\n");
set_strength(2);
set_heal(3);
set_value(10);
set_weight(1);
set_full(1);
set_empty_container("keg");
set_soft_strength(0);
add_id(({ "beer", "bottle" }));
static void
create()
{
::create();
set_name("wein");
set_short("a huge keg of Wittgensteiner wein");
set_drinking_mess(" raises a keg, and burps contendedly after having " +
"some.\n");
set_drinker_mess("You put the keg to your mouth, and drink some of the " +
"wein. Gaaaaah.\n");
set_strength(30);
set_heal(45);
set_value(600);
set_weight(1);
set_full(3);
set_empty_container("keg");
set_soft_strength(5);
add_id(({ "wine", "keg" }));
/* Function: p7_checkptmx_GrowTo()
* Synopsis: Resize checkpointed DP matrix for new seq/model comparison.
*
* Purpose: Given an existing checkpointed matrix structure <ox>,
* and the dimensions <M> and <L> of a new comparison,
* reallocate and reinitialize <ox>.
*
* Essentially the same as free'ing the previous matrix and
* creating a new one -- but minimizes expensive memory
* allocation/reallocation calls.
*
* Usually <ox> only grows. The exception is if <ox> is
* redlined (over its recommended allocation) and the new
* problem size <M,L> can fit in the preset recommended
* allocation, then <ox> is reallocated down to the smaller
* recommended size.
*
* Args: ox - existing checkpointed matrix
* M - new query profile length
* L - new target sequence length
*
* Returns: <eslOK> on success.
*
* Throws: <eslEMEM> if an allocation fails. The state of <ox> is
* now undefined, and the caller should not use it.
*/
int
p7_checkptmx_GrowTo(P7_CHECKPTMX *ox, int M, int L)
{
int minR_chk = (int) ceil(minimum_rows(L)) + ox->R0; /* minimum number of DP rows needed */
int reset_dp_ptrs = FALSE;
int maxR;
int64_t W; /* minimum row width needed, bytes */
int r;
int status;
/* Validity of integer variable ranges may depend on design spec: */
ESL_DASSERT1( (M <= 100000) ); /* design spec says, model length M <= 100000 */
ESL_DASSERT1( (L <= 100000) ); /* ... and, seq length L <= 100000 */
ESL_DASSERT1( (L > 0) );
ESL_DASSERT1( (M > 0) );
/* If we're debugging and we have stored copies of any matrices,
* grow them too. Must do this first, because we have an early exit
* condition coming below.
*/
#ifdef p7_DEBUGGING
if (ox->fwd && (status = p7_refmx_GrowTo(ox->fwd, M, L)) != eslOK) goto ERROR;
if (ox->bck && (status = p7_refmx_GrowTo(ox->bck, M, L)) != eslOK) goto ERROR;
if (ox->pp && (status = p7_refmx_GrowTo(ox->pp, M, L)) != eslOK) goto ERROR;
#endif
/* Calculate W, the minimum row width needed, in bytes */
W = sizeof(float) * P7_NVF(M) * p7C_NSCELLS * p7_VNF; /* vector part of row (MDI) */
W += ESL_UPROUND(sizeof(float) * p7C_NXCELLS, p7_VALIGN); /* float part of row (specials); must maintain p7_VALIGN-byte alignment */
/* Are current allocations satisfactory ? */
if (W <= ox->allocW && ox->nalloc <= ox->ramlimit)
{
if (L + ox->R0 <= ox->validR) { set_full (ox, L); return eslOK; }
else if (minR_chk <= ox->validR) { set_checkpointed(ox, L, ox->validR); return eslOK; }
}
/* Do individual matrix rows need to expand? */
if ( W > ox->allocW)
{
ox->allocW = W;
ox->validR = (int) (ox->nalloc / ox->allocW); /* validR must be <= allocR */
reset_dp_ptrs = TRUE;
}
/* Does matrix dp_mem need reallocation, either up or down? */
maxR = (int) (ox->nalloc / ox->allocW); /* max rows if we use up to the recommended allocation size. */
if ( (ox->nalloc > ox->ramlimit && minR_chk <= maxR) || /* we were redlined, and recommended alloc will work: so downsize */
minR_chk > ox->validR) /* not enough memory for needed rows: so upsize */
{
set_row_layout(ox, L, maxR);
ox->validR = ox->R0 + ox->Ra + ox->Rb + ox->Rc; /* this may be > allocR now; we'll reallocate dp[] next, if so */
ox->nalloc = ox->validR * ox->allocW;
ESL_REALLOC(ox->dp_mem, ox->nalloc + (p7_VALIGN-1)); /* (p7_VALIGN-1) because we will manually align dpf ptrs into dp_mem */
reset_dp_ptrs = TRUE;
}
else /* current validR will suffice, either full or checkpointed; we still need to calculate a layout */
{
if (L+ox->R0 <= ox->validR) set_full(ox, L);
else set_checkpointed(ox, L, ox->validR);
}
/* Does the array of row ptrs need reallocation? */
if (ox->validR > ox->allocR)
{
ESL_REALLOC(ox->dpf, sizeof(float *) * ox->validR);
ox->allocR = ox->validR;
reset_dp_ptrs = TRUE;
}
/* Do the row ptrs need to be reset? */
if (reset_dp_ptrs)
{
ox->dpf[0] = (char *) ( ( (uintptr_t) ox->dp_mem + p7_VALIGN - 1) & p7_VALIMASK); /* vectors must be aligned on p7_VALIGN-byte boundary */
for (r = 1; r < ox->validR; r++)
ox->dpf[r] = ox->dpf[0] + (r * ox->allocW);
}
return eslOK;
ERROR:
return status;
}
