static void mel_loglookup_with_offset(front_cep *cepobj,
front_channel *channel)
/*
** pwr spect -> filter bank output */
{
int ii;
if (channel->shift > 0)
for (ii = 0; ii < channel->num_freq; ii++)
{
channel->filterbank[ii] = (cepdata) log_lookup(&cepobj->logtab,
(int)(channel->filterbank[ii] +
SHIFT_DOWN(cepobj->mel_offset[ii], channel->shift)),
channel->shift);
}
else
for (ii = 0; ii < channel->num_freq; ii++)
{
channel->filterbank[ii] = (cepdata) log_lookup(&cepobj->logtab,
(int)(channel->filterbank[ii] +
SHIFT_UP(cepobj->mel_offset[ii], -channel->shift)),
channel->shift);
}
return;
}
void inverse_transform_frame (preprocessed *prep, imeldata *fram, int do_shift)
/*
** Note the matrix is the transpose of the transformation
** To transform a single frame in place */
{
int ii, jj;
imeldata vec[MAX_DIMEN];
ASSERT (prep);
ASSERT (prep->dim < MAX_DIMEN);
ASSERT (fram);
if (prep->offset && do_shift)
for (ii= 0; ii < prep->dim; ii++)
fram[ii] -= prep->offset[ii];
for (ii= 0; ii < prep->dim; ii++) {
vec[ii]= 0;
for (jj= 0; jj < prep->dim; jj++)
vec[ii] += prep->invmat[ii][jj] * fram[jj];
vec[ii]= SHIFT_DOWN (vec[ii], prep->inv_shift);
//floating pt // for (jj= 0; jj < prep->dim; jj++)
//floating pt // vec[ii] += (imeldata)(prep->inverse[ii][jj] * fram[jj]);
}
if (do_shift)
for (ii= 0; ii < prep->dim; ii++)
fram[ii]= RANGE (vec[ii], 0, 255);
else
for (ii= 0; ii < prep->dim; ii++)
fram[ii]= vec[ii];
return;
}
/*
* With support for nonblocking collectives, we don't have an upper
* limit on the number of outstanding collectives per communicator.
* Also, since we want to avoid communication to figure out which
* buffers other ranks in the group will use, we will rely on the
* fact that collective operations are called in the same order
* in each process, to assign a unique ID to each collective operation.
* We use this to create a static mapping from the index to the buffer
* that will be used. Also, because there is no limit to the number of
* outstanding collective operations, we use a generation index for each
* memory bank, so the collective will use the buffer only when the
* correct generation of the bank is ready for use.
*/
int bcol_basesmuma_get_buff_index( sm_buffer_mgmt *buff_block,
uint64_t buff_id )
{
/* local variables */
int memory_bank;
uint64_t generation;
int index=-1;
/* get the bank index that will be used */
memory_bank=buff_id& buff_block->mask;
memory_bank = memory_bank SHIFT_DOWN buff_block->log2_num_buffs_per_mem_bank;
/* get the generation of the bank this maps to */
generation = buff_id SHIFT_DOWN (buff_block->log2_number_of_buffs);
/* check to see if the bank is available */
if( generation == buff_block->ctl_buffs_mgmt[memory_bank].
bank_gen_counter ) {
/* get the buffer index that will be returned */
index=buff_id & buff_block->mask;
/* no in-use counter increment, as the mapping is static, and
* all we need to know if the number of collectives that complete */
} else {
/* progress communications so that resources can be freed up */
opal_progress();
}
/* return */
return index;
}
void linear_transform_frame(preprocessed *prep, imeldata *fram, int do_shift)
/*
** Note the matrix is the transpose of the transformation
** To transform a single frame in place */
{
int ii, jj;
imeldata vec[MAX_DIMEN];
int dim = prep->dim;
ASSERT(prep);
ASSERT(prep->dim < MAX_DIMEN);
ASSERT(fram);
for (ii = 0; ii < dim; ii++)
{
vec[ii] = 0;
for (jj = 0; jj < prep->dim; jj++)
vec[ii] += prep->matrix[ii][jj] * fram[jj];
ASSERT(prep->imel_shift > 0);
vec[ii] = (imeldata) SHIFT_DOWN((int)vec[ii],
(unsigned int)prep->imel_shift);
}
if (do_shift)
{
if (prep->offset)
for (ii = 0; ii < dim; ii++)
fram[ii] = RANGE(vec[ii] + prep->offset[ii], 0, 255);
else
for (ii = 0; ii < dim; ii++)
fram[ii] = RANGE(vec[ii], 0, 255);
}
else
{
for (ii = 0; ii < dim; ii++)
fram[ii] = vec[ii];
}
return;
}
/* release the shared memory buffers
* buf_id is the unique ID assigned to the particular buffer
*/
int bcol_basesmuma_free_buff( sm_buffer_mgmt * buff_block,
uint64_t buff_id )
{
/* local variables */
int ret=OMPI_SUCCESS;
int memory_bank;
uint64_t generation;
mca_bcol_basesmuma_component_t *cs = &mca_bcol_basesmuma_component;
/* get the bank index that will be used */
memory_bank=buff_id& buff_block->mask;
memory_bank = memory_bank SHIFT_DOWN buff_block->log2_num_buffs_per_mem_bank;
/* get the generation of the bank this maps to */
generation = buff_id SHIFT_DOWN (buff_block->log2_number_of_buffs);
/* the generation counter should not change until all resrouces
* associated with this bank have been freed.
*/
assert(generation == buff_block->ctl_buffs_mgmt[memory_bank].bank_gen_counter);
/*
* increment counter of completed buffers
*/
OPAL_THREAD_ADD32(&(buff_block->ctl_buffs_mgmt[memory_bank].n_buffs_freed),
1);
/*
* If I am the last to checkin - initiate resource recycling
*/
if( buff_block->ctl_buffs_mgmt[memory_bank].n_buffs_freed ==
buff_block->ctl_buffs_mgmt[memory_bank].number_of_buffers ) {
/* Lock to ensure atomic recycling of resources */
OPAL_THREAD_LOCK(&(buff_block->ctl_buffs_mgmt[memory_bank].mutex));
/* make sure someone else did not already get to this */
if( buff_block->ctl_buffs_mgmt[memory_bank].n_buffs_freed !=
buff_block->ctl_buffs_mgmt[memory_bank].number_of_buffers ) {
/* release lock and exit */
OPAL_THREAD_UNLOCK(&(buff_block->ctl_buffs_mgmt[memory_bank].mutex));
} else {
sm_nbbar_desc_t *p_sm_nb_desc = NULL;
/* initiate the freeing of resources. Need to make sure the other
* ranks in the group are also done with their resources before this
* block is made available for use again.
* No one else will try to allocate from this block or free back to
* this block until the next genration counter has been incremented,
* so will just reset the number of freed buffers to 0, so no one else
* will try to also initialize the recycling of these resrouces
*/
buff_block->ctl_buffs_mgmt[memory_bank].n_buffs_freed=0;
/* Start the nonblocking barrier */
p_sm_nb_desc = &(buff_block->ctl_buffs_mgmt[memory_bank].nb_barrier_desc);
p_sm_nb_desc->coll_buff = buff_block;
bcol_basesmuma_rd_nb_barrier_init_admin(p_sm_nb_desc);
if( NB_BARRIER_DONE !=
buff_block->ctl_buffs_mgmt[memory_bank].
nb_barrier_desc.collective_phase) {
opal_list_t *list=&(cs->nb_admin_barriers);
opal_list_item_t *append_item;
/* put this onto the progression list */
OPAL_THREAD_LOCK(&(cs->nb_admin_barriers_mutex));
append_item=(opal_list_item_t *)
&(buff_block->ctl_buffs_mgmt[memory_bank].nb_barrier_desc);
opal_list_append(list,append_item);
OPAL_THREAD_UNLOCK(&(cs->nb_admin_barriers_mutex));
/* progress communications so that resources can be freed up */
opal_progress();
} else {
/* mark the block as available */
(buff_block->ctl_buffs_mgmt[memory_bank].bank_gen_counter)++;
}
/* get out of here */
OPAL_THREAD_UNLOCK(&(buff_block->ctl_buffs_mgmt[memory_bank].mutex));
}
}
/* return */
return ret;
}
