void bli_packv_init
(
obj_t* a,
obj_t* p,
cntx_t* cntx,
packv_t* cntl
)
{
// The purpose of packm_init() is to initialize an object P so that
// a source object A can be packed into P via one of the packv
// implementations. This initialization includes acquiring a suitable
// block of memory from the memory allocator, if such a block of memory
// has not already been allocated previously.
pack_t pack_schema;
bszid_t bmult_id;
// Check parameters.
if ( bli_error_checking_is_enabled() )
bli_packv_check( a, p, cntx );
// First check if we are to skip this operation because the control tree
// is NULL, and if so, simply alias the object to its packed counterpart.
if ( bli_cntl_is_noop( cntl ) )
{
bli_obj_alias_to( a, p );
return;
}
// At this point, we can be assured that cntl is not NULL. Let us now
// check to see if the object has already been packed to the desired
// schema (as encoded in the control tree). If so, we can alias and
// return, as above.
// Note that in most cases, bli_obj_pack_schema() will return
// BLIS_NOT_PACKED and thus packing will be called for (but in some
// cases packing has already taken place). Also, not all combinations
// of current pack status and desired pack schema are valid.
if ( bli_obj_pack_schema( a ) == cntl_pack_schema( cntl ) )
{
bli_obj_alias_to( a, p );
return;
}
// Now, if we are not skipping the pack operation, then the only question
// left is whether we are to typecast vector a before packing.
if ( bli_obj_dt( a ) != bli_obj_target_dt( a ) )
bli_abort();
// Extract various fields from the control tree and pass them in
// explicitly into _init_pack(). This allows external code generators
// the option of bypassing usage of control trees altogether.
pack_schema = cntl_pack_schema( cntl );
bmult_id = cntl_bmid( cntl );
// Initialize object p for the final packed vector.
bli_packv_init_pack
(
pack_schema,
bmult_id,
&a,
p,
cntx
);
// Now p is ready to be packed.
}
void bli_packv_int( obj_t* a,
obj_t* p,
cntx_t* cntx,
packv_t* cntl )
{
// The packv operation consists of an optional typecasting pre-process.
// Here are the following possible ways packv can execute:
// 1. cast and pack: When typecasting and packing are both
// precribed, typecast a to temporary vector c and then pack
// c to p.
// 2. pack only: Typecasting is skipped when it is not needed;
// simply pack a directly to p.
// 3. cast only: Not yet supported / not used.
// 4. no-op: The control tree sometimes directs us to skip the
// pack operation entirely. Alias p to a and return.
//obj_t c;
varnum_t n;
impl_t i;
FUNCPTR_T f;
// Check parameters.
if ( bli_error_checking_is_enabled() )
bli_packv_check( a, p, cntx );
// Sanity check; A should never have a zero dimension. If we must support
// it, then we should fold it into the next alias-and-early-exit block.
//if ( bli_obj_has_zero_dim( *a ) ) bli_abort();
// First check if we are to skip this operation because the control tree
// is NULL. We return without taking any action because a was already
// aliased to p in packv_init().
if ( cntl_is_noop( cntl ) )
{
return;
}
// Let us now check to see if the object has already been packed. First
// we check if it has been packed to an unspecified (row or column)
// format, in which case we can return, since by now aliasing has already
// taken place in packv_init().
// NOTE: The reason we don't need to even look at the control tree in
// this case is as follows: an object's pack status is only set to
// BLIS_PACKED_UNSPEC for situations when the actual format used is
// not important, as long as its packed into contiguous rows or
// contiguous columns. A good example of this is packing for matrix
// operands in the level-2 operations.
if ( bli_obj_pack_schema( *a ) == BLIS_PACKED_UNSPEC )
{
return;
}
// At this point, we can be assured that cntl is not NULL. Now we check
// if the object has already been packed to the desired schema (as en-
// coded in the control tree). If so, we can return, as above.
// NOTE: In most cases, an object's pack status will be BLIS_NOT_PACKED
// and thus packing will be called for (but in some cases packing has
// already taken place, or does not need to take place, and so that will
// be indicated by the pack status). Also, not all combinations of
// current pack status and desired pack schema are valid.
if ( bli_obj_pack_schema( *a ) == cntl_pack_schema( cntl ) )
{
return;
}
// Extract the variant number and implementation type.
n = cntl_var_num( cntl );
i = cntl_impl_type( cntl );
// Index into the variant array to extract the correct function pointer.
f = vars[n][i];
// Invoke the variant.
f( a,
p,
cntx,
cntl );
}
