(r)

Functions
void	blas_set_parameter (void)

fla_blocksize_t *	FLA_Blocksize_create (dim_t b_s, dim_t b_d, dim_t b_c, dim_t b_z)

void	FLA_Blocksize_set (fla_blocksize_t *bp, dim_t b_s, dim_t b_d, dim_t b_c, dim_t b_z)

void	FLA_Blocksize_scale (fla_blocksize_t *bp, double factor)

fla_blocksize_t *	FLA_Blocksize_create_copy (fla_blocksize_t *bp)

void	FLA_Blocksize_free (fla_blocksize_t *bp)

dim_t	FLA_Blocksize_extract (FLA_Datatype dt, fla_blocksize_t *bp)

fla_blocksize_t *	FLA_Query_blocksizes (FLA_Dimension dim)

dim_t	FLA_Query_blocksize (FLA_Datatype dt, FLA_Dimension dim)

dim_t	FLA_Determine_blocksize (FLA_Obj A_unproc, FLA_Quadrant to_dir, fla_blocksize_t *bp)

dim_t	FLA_determine_matrix_size (FLA_Obj A_unproc, FLA_Quadrant to_dir)

Variables
long	sgemm_p

long	sgemm_q

long	sgemm_r

long	dgemm_p

long	dgemm_q

long	dgemm_r

long	cgemm_p

long	cgemm_q

long	cgemm_r

long	zgemm_p

long	zgemm_q

long	zgemm_r

long	fla_goto_gemm_blocksize [4][4]

Function Documentation

◆ blas_set_parameter()

void blas_set_parameter ( void )

extern

◆ FLA_Blocksize_create()

fla_blocksize_t * FLA_Blocksize_create	(	dim_t	b_s,
		dim_t	b_d,
		dim_t	b_c,
		dim_t	b_z )

{
    fla_blocksize_t* bp;
    
    // Allocate memory for the blocksize structure.
    bp = ( fla_blocksize_t* ) FLA_malloc( sizeof(fla_blocksize_t) );
    
    // Assign the provided blocksize values into the corresponding fields.
    bp->s = b_s;
    bp->d = b_d;
    bp->c = b_c;
    bp->z = b_z;
    
    // Return a pointer to the structure.
    return bp;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_malloc(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

◆ FLA_Blocksize_create_copy()

fla_blocksize_t * FLA_Blocksize_create_copy ( fla_blocksize_t * bp )

{
    fla_blocksize_t* bp_copy;
    FLA_Error        e_val;
    
    // Verify that the given blocksize pointer is valid.
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    {
        e_val = FLA_Check_null_pointer( bp );
        FLA_Check_error_code( e_val );
    }
 
    // Allocate memory for the blocksize structure.
    bp_copy = ( fla_blocksize_t* ) FLA_malloc( sizeof(fla_blocksize_t) );
    
    // Assign the provided blocksize object's values into the corresponding
    // fields of the new object.
    bp_copy->s = bp->s;
    bp_copy->d = bp->d;
    bp_copy->c = bp->c;
    bp_copy->z = bp->z;
    
    // Return a pointer to the structure.
    return bp_copy;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Check_error_level(), FLA_Check_null_pointer(), FLA_malloc(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

Referenced by FLA_Chol_cntl_init(), FLA_LU_nopiv_cntl_init(), and FLA_LU_piv_cntl_init().

◆ FLA_Blocksize_extract()

dim_t FLA_Blocksize_extract	(	FLA_Datatype	dt,
		fla_blocksize_t *	bp )

{
    dim_t     b = 0;
    FLA_Error e_val;
 
    // Verify that the given blocksize pointer is valid.
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    {
        e_val = FLA_Check_null_pointer( bp );
        FLA_Check_error_code( e_val );
    }
 
    if      ( dt == FLA_FLOAT )
        b = bp->s;
    else if ( dt == FLA_DOUBLE )
        b = bp->d;
    else if ( dt == FLA_COMPLEX )
        b = bp->c;
    else if ( dt == FLA_DOUBLE_COMPLEX )
        b = bp->z;
    
    // Return the blocksize corresponding with the datatype.
    return b;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Check_error_level(), FLA_Check_null_pointer(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

Referenced by FLA_Check_blocksize_object(), FLA_Determine_blocksize(), FLA_Trinv(), and FLA_Ttmm().

◆ FLA_Blocksize_free()

void FLA_Blocksize_free ( fla_blocksize_t * bp )

{
    FLA_free( bp );
}

References FLA_free().

◆ FLA_Blocksize_scale()

void FLA_Blocksize_scale	(	fla_blocksize_t *	bp,
		double	factor )

{
    FLA_Error e_val;
    
    // Verify that the given blocksize pointer is valid.
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    {
        e_val = FLA_Check_null_pointer( bp );
        FLA_Check_error_code( e_val );
    }
    
    // Assign the provided blocksize values into the corresponding fields.
    bp->s = ( dim_t )( ( double ) bp->s * factor );
    bp->d = ( dim_t )( ( double ) bp->d * factor );
    bp->c = ( dim_t )( ( double ) bp->c * factor );
    bp->z = ( dim_t )( ( double ) bp->z * factor );
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Check_error_level(), FLA_Check_null_pointer(), FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

Referenced by FLA_Apply_CAQ2_UT_cntl_init(), FLA_Apply_Q2_UT_cntl_init(), FLA_Apply_Q_UT_cntl_init(), FLA_Apply_QUD_UT_cntl_init(), FLA_Bidiag_UT_cntl_init(), FLA_CAQR2_UT_cntl_init(), FLA_Chol_cntl_init(), FLA_Hess_UT_cntl_init(), FLA_LQ_UT_cntl_init(), FLA_LU_nopiv_cntl_init(), FLA_LU_piv_cntl_init(), FLA_QR2_UT_cntl_init(), FLA_QR_UT_cntl_init(), FLA_Tridiag_UT_cntl_init(), and FLA_UDdate_UT_cntl_init().

◆ FLA_Blocksize_set()

void FLA_Blocksize_set	(	fla_blocksize_t *	bp,
		dim_t	b_s,
		dim_t	b_d,
		dim_t	b_c,
		dim_t	b_z )

{
    // Assign the provided blocksize values into the corresponding fields.
    if ( b_s != 0 ) bp->s = b_s;
    if ( b_d != 0 ) bp->d = b_d;
    if ( b_c != 0 ) bp->c = b_c;
    if ( b_z != 0 ) bp->z = b_z;
}

References FLA_Blocksize_s::c, FLA_Blocksize_s::d, FLA_Blocksize_s::s, and FLA_Blocksize_s::z.

Referenced by FLASH_Apply_Q_UT().

◆ FLA_Determine_blocksize()

dim_t FLA_Determine_blocksize	(	FLA_Obj	A_unproc,
		FLA_Quadrant	to_dir,
		fla_blocksize_t *	bp )

{
    FLA_Error    e_val;
    FLA_Datatype datatype;
    dim_t        A_unproc_size;
    dim_t        typed_blocksize;
    dim_t        b;
 
    // Determine the size of the remaining portion of the matrix.
    A_unproc_size = FLA_determine_matrix_size( A_unproc, to_dir );
    
    // Determine the datatype of the matrix.
    datatype = FLA_Obj_datatype( A_unproc );
    
    // Determine the raw blocksize value from the blocksize structure.
    typed_blocksize = FLA_Blocksize_extract( datatype, bp );
 
    // Check blocksize for zero value.
    if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
    {
        e_val = FLA_Check_blocksize_value( typed_blocksize );
        FLA_Check_error_code( e_val );
    }
 
    // If the unprocessed partition is smaller than our blocksize allows,
    // we have to use it's length/width instead.
    b = min( A_unproc_size, typed_blocksize );
    
    // Return the computed blocksize.
    return b;
}

References FLA_Blocksize_extract(), FLA_Check_blocksize_value(), FLA_Check_error_level(), FLA_determine_matrix_size(), and FLA_Obj_datatype().

◆ FLA_determine_matrix_size()

dim_t FLA_determine_matrix_size	(	FLA_Obj	A_unproc,
		FLA_Quadrant	to_dir )

{
    dim_t r_val = 0;
 
    // Determine the size of the matrix dimension along which we are moving.
    switch( to_dir )
    {
        case FLA_TOP:
        case FLA_BOTTOM:
        {
            r_val = FLA_Obj_length( A_unproc );
            break;
        }
        case FLA_LEFT:
        case FLA_RIGHT:
        {
            r_val = FLA_Obj_width( A_unproc );
            break;
        }
        case FLA_TL:
        case FLA_TR:
        case FLA_BL:
        case FLA_BR:
        {
            // We need to use min_dim() here because the matrix might be
            // rectangular.
            r_val = FLA_Obj_min_dim( A_unproc );
            break;
        }
    }
    
    return r_val;
}

References FLA_Obj_length(), FLA_Obj_min_dim(), and FLA_Obj_width().

Referenced by FLA_Determine_blocksize().

◆ FLA_Query_blocksize()

dim_t FLA_Query_blocksize	(	FLA_Datatype	dt,
		FLA_Dimension	dim )

{
    dim_t b_val = 0;
 
#ifdef FLA_ENABLE_GOTO_INTERFACES
 
    int dt_index;
    int dim_index;
 
    if ( first_time )
    {
        long sgemm_min, dgemm_min, cgemm_min, zgemm_min;
        
        // Find the blocksizes associated with FLA_DIMENSION_MIN.
        sgemm_min = min( sgemm_p, sgemm_q );
        dgemm_min = min( dgemm_p, dgemm_q );
        cgemm_min = min( cgemm_p, cgemm_q );
        zgemm_min = min( zgemm_p, zgemm_q );
 
        // Set the values for each datatype and dimension constant.
        fla_goto_gemm_blocksize[FLA_S_INDEX][FLA_DIM_M_INDEX]   = sgemm_p;
        fla_goto_gemm_blocksize[FLA_S_INDEX][FLA_DIM_K_INDEX]   = sgemm_q;
        fla_goto_gemm_blocksize[FLA_S_INDEX][FLA_DIM_N_INDEX]   = sgemm_r;
        fla_goto_gemm_blocksize[FLA_S_INDEX][FLA_DIM_MIN_INDEX] = sgemm_min;
 
        fla_goto_gemm_blocksize[FLA_D_INDEX][FLA_DIM_M_INDEX]   = dgemm_p;
        fla_goto_gemm_blocksize[FLA_D_INDEX][FLA_DIM_K_INDEX]   = dgemm_q;
        fla_goto_gemm_blocksize[FLA_D_INDEX][FLA_DIM_N_INDEX]   = dgemm_r;
        fla_goto_gemm_blocksize[FLA_D_INDEX][FLA_DIM_MIN_INDEX] = dgemm_min;
 
        fla_goto_gemm_blocksize[FLA_C_INDEX][FLA_DIM_M_INDEX]   = cgemm_p;
        fla_goto_gemm_blocksize[FLA_C_INDEX][FLA_DIM_K_INDEX]   = cgemm_q;
        fla_goto_gemm_blocksize[FLA_C_INDEX][FLA_DIM_N_INDEX]   = cgemm_r;
        fla_goto_gemm_blocksize[FLA_C_INDEX][FLA_DIM_MIN_INDEX] = cgemm_min;
 
        fla_goto_gemm_blocksize[FLA_Z_INDEX][FLA_DIM_M_INDEX]   = zgemm_p;
        fla_goto_gemm_blocksize[FLA_Z_INDEX][FLA_DIM_K_INDEX]   = zgemm_q;
        fla_goto_gemm_blocksize[FLA_Z_INDEX][FLA_DIM_N_INDEX]   = zgemm_r;
        fla_goto_gemm_blocksize[FLA_Z_INDEX][FLA_DIM_MIN_INDEX] = zgemm_min;
 
        first_time = FALSE;
    }
 
    // Compute the index of the requested datatype.
    dt_index  = dt  & FLA_DTYPE_INDEX_MASK;
    dim_index = dim & FLA_DIM_INDEX_MASK;
 
    // Index into the array and choose the appropriate blocksize.
    b_val = ( dim_t ) fla_goto_gemm_blocksize[dt_index][dim_index];
 
#else
 
    // Assign the return value to a default sane blocksize in case
    // we cannot access the libgoto symbols.
    if      ( dim == FLA_DIMENSION_M )
        b_val = FLA_DEFAULT_M_BLOCKSIZE;
    else if ( dim == FLA_DIMENSION_K )
        b_val = FLA_DEFAULT_K_BLOCKSIZE;
    else if ( dim == FLA_DIMENSION_N )
        b_val = FLA_DEFAULT_N_BLOCKSIZE;
    else if ( dim == FLA_DIMENSION_MIN )
    {
        b_val = min( FLA_DEFAULT_M_BLOCKSIZE, FLA_DEFAULT_K_BLOCKSIZE );
        b_val = min( b_val, FLA_DEFAULT_N_BLOCKSIZE );
    }
 
#endif
 
    // Return the blocksize.
    return b_val;
}

References cgemm_p, cgemm_q, cgemm_r, dgemm_p, dgemm_q, dgemm_r, fla_goto_gemm_blocksize, sgemm_p, sgemm_q, sgemm_r, zgemm_p, zgemm_q, and zgemm_r.

Referenced by FLA_Apply_Q_blk_external(), FLA_Bidiag_blk_external(), FLA_Bidiag_UT_create_T(), FLA_Check_householder_panel_dims(), FLA_Hess_blk_external(), FLA_Hess_UT_create_T(), FLA_LQ_blk_external(), FLA_LQ_UT_create_T(), FLA_QR_blk_external(), FLA_QR_UT_create_T(), FLA_Query_blocksizes(), FLA_Tridiag_blk_external(), FLA_Tridiag_form_Q_external(), FLA_Tridiag_UT_create_T(), and FLA_UDdate_UT_create_T().

◆ FLA_Query_blocksizes()

fla_blocksize_t * FLA_Query_blocksizes ( FLA_Dimension dim )

{
    fla_blocksize_t* bp;
    
    // Create an FLA_Blocksize_t object.
    bp = FLA_Blocksize_create( 0, 0, 0, 0 );
    
    // Query the requested blocksize (m, k, or n dimension) for all of the
    // datatypes and package the results in an FLA_Blocksize_t structure.
    bp->s = FLA_Query_blocksize( FLA_FLOAT, dim );
    bp->d = FLA_Query_blocksize( FLA_DOUBLE, dim );
    bp->c = FLA_Query_blocksize( FLA_COMPLEX, dim );
    bp->z = FLA_Query_blocksize( FLA_DOUBLE_COMPLEX, dim );
    
    // Return a pointer to the structure.
    return bp;
}