Esempio n. 1
0
void libblis_test_dotxaxpyf_check
     (
       test_params_t* params,
       obj_t*         alpha,
       obj_t*         at,
       obj_t*         a,
       obj_t*         w,
       obj_t*         x,
       obj_t*         beta,
       obj_t*         y,
       obj_t*         z,
       obj_t*         y_orig,
       obj_t*         z_orig,
       double*        resid
     )
{
	num_t  dt      = bli_obj_datatype( *y );
	num_t  dt_real = bli_obj_datatype_proj_to_real( *y );

	dim_t  m       = bli_obj_vector_dim( *z );
	dim_t  b_n     = bli_obj_vector_dim( *y );

	dim_t  i;

	obj_t  a1, chi1, psi1, v, q;
	obj_t  alpha_chi1;
	obj_t  norm;

	double resid1, resid2;
	double junk;

	//
	// Pre-conditions:
	// - a is randomized.
	// - w is randomized.
	// - x is randomized.
	// - y is randomized.
	// - z is randomized.
	// - at is an alias to a.
	// Note:
	// - alpha and beta should have a non-zero imaginary component in the
	//   complex cases in order to more fully exercise the implementation.
	//
	// Under these conditions, we assume that the implementation for
	//
	//   y := beta * y_orig + alpha * conjat(A^T) * conjw(w)
	//   z :=        z_orig + alpha * conja(A)    * conjx(x)
	//
	// is functioning correctly if
	//
	//   normf( y - v )
	//
	// and
	//
	//   normf( z - q )
	//
	// are negligible, where v and q contain y and z as computed by repeated
	// calls to dotxv and axpyv, respectively.
	//

	bli_obj_scalar_init_detached( dt_real, &norm );
	bli_obj_scalar_init_detached( dt,      &alpha_chi1 );

	bli_obj_create( dt, b_n, 1, 0, 0, &v );
	bli_obj_create( dt, m,   1, 0, 0, &q );

	bli_copyv( y_orig, &v );
	bli_copyv( z_orig, &q );

	// v := beta * v + alpha * conjat(at) * conjw(w)
	for ( i = 0; i < b_n; ++i )
	{
		bli_acquire_mpart_l2r( BLIS_SUBPART1, i, 1, at, &a1 );
		bli_acquire_vpart_f2b( BLIS_SUBPART1, i, 1, &v, &psi1 );

		bli_dotxv( alpha, &a1, w, beta, &psi1 );
	}

	// q := q + alpha * conja(a) * conjx(x)
	for ( i = 0; i < b_n; ++i )
	{
		bli_acquire_mpart_l2r( BLIS_SUBPART1, i, 1, a, &a1 );
		bli_acquire_vpart_f2b( BLIS_SUBPART1, i, 1, x, &chi1 );

		bli_copysc( &chi1, &alpha_chi1 );
		bli_mulsc( alpha, &alpha_chi1 );

		bli_axpyv( &alpha_chi1, &a1, &q );
	}


	bli_subv( y, &v );
	bli_normfv( &v, &norm );
	bli_getsc( &norm, &resid1, &junk );

	bli_subv( z, &q );
	bli_normfv( &q, &norm );
	bli_getsc( &norm, &resid2, &junk );


	*resid = bli_fmaxabs( resid1, resid2 );

	bli_obj_free( &v );
	bli_obj_free( &q );
}
Esempio n. 2
0
void bli_gemv_blk_var2( obj_t*  alpha,
                        obj_t*  a,
                        obj_t*  x,
                        obj_t*  beta,
                        obj_t*  y,
                        cntx_t* cntx,
                        gemv_t* cntl )
{
	obj_t a1, a1_pack;
	obj_t x1, x1_pack;

	dim_t n_trans;
	dim_t i;
	dim_t b_alg;

	// Initialize objects for packing.
	bli_obj_init_pack( &a1_pack );
	bli_obj_init_pack( &x1_pack );

	// Query dimension in partitioning direction.
	n_trans = bli_obj_width_after_trans( a );

	// y = beta * y;
	bli_scalv_int( beta,
	               y,
	               cntx, bli_cntl_sub_scalv( cntl ) );

	// Partition along the "k" dimension (n dimension of A).
	for ( i = 0; i < n_trans; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		b_alg = bli_determine_blocksize_f( i, n_trans, a,
		                                   bli_cntl_bszid( cntl ), cntx );

		// Acquire partitions for A1 and x1.
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, a, &a1 );
		bli_acquire_vpart_f2b( BLIS_SUBPART1,
		                       i, b_alg, x, &x1 );

		// Initialize objects for packing A1 and x1 (if needed).
		bli_packm_init( &a1, &a1_pack,
		                cntx, bli_cntl_sub_packm_a( cntl ) );
		bli_packv_init( &x1, &x1_pack,
		                cntx, bli_cntl_sub_packv_x( cntl ) );

		// Copy/pack A1, x1 (if needed).
		bli_packm_int( &a1, &a1_pack,
		               cntx, bli_cntl_sub_packm_a( cntl ),
                       &BLIS_PACKM_SINGLE_THREADED );
		bli_packv_int( &x1, &x1_pack,
		               cntx, bli_cntl_sub_packv_x( cntl ) );

		// y = y + alpha * A1 * x1;
		bli_gemv_int( BLIS_NO_TRANSPOSE,
		              BLIS_NO_CONJUGATE,
		              alpha,
		              &a1_pack,
		              &x1_pack,
		              &BLIS_ONE,
		              y,
		              cntx,
		              bli_cntl_sub_gemv( cntl ) );
	}

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
	bli_packm_release( &a1_pack, bli_cntl_sub_packm_a( cntl ) );
	bli_packv_release( &x1_pack, bli_cntl_sub_packv_x( cntl ) );
}
Esempio n. 3
0
void bli_ger_blk_var2( obj_t* alpha,
                       obj_t* x,
                       obj_t* y,
                       obj_t* a,
                       cntx_t* cntx,
                       ger_t* cntl )
{
	obj_t a1, a1_pack;
	obj_t y1, y1_pack;

	dim_t i;
	dim_t b_alg;
	dim_t n_trans;

	// Initialize objects for packing.
	bli_obj_init_pack( &a1_pack );
	bli_obj_init_pack( &y1_pack );

	// Query dimension in partitioning direction.
	n_trans = bli_obj_width_after_trans( *a );

	// Partition along the n dimension.
	for ( i = 0; i < n_trans; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		b_alg = bli_determine_blocksize_f( i, n_trans, a,
		                                   bli_cntl_bszid( cntl ), cntx );

		// Acquire partitions for A1 and y1.
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, a, &a1 );
		bli_acquire_vpart_f2b( BLIS_SUBPART1,
		                       i, b_alg, y, &y1 );

		// Initialize objects for packing A1 and y1 (if needed).
		bli_packm_init( &a1, &a1_pack,
		                cntx, bli_cntl_sub_packm_a( cntl ) );
		bli_packv_init( &y1, &y1_pack,
		                cntx, bli_cntl_sub_packv_y( cntl ) );

		// Copy/pack A1, y1 (if needed).
		bli_packm_int( &a1, &a1_pack,
		               cntx, bli_cntl_sub_packm_a( cntl ),
                       &BLIS_PACKM_SINGLE_THREADED );
		bli_packv_int( &y1, &y1_pack,
		               cntx, bli_cntl_sub_packv_y( cntl ) );

		// A1 = A1 + alpha * x * y1;
		bli_ger_int( BLIS_NO_CONJUGATE,
		             BLIS_NO_CONJUGATE,
		             alpha,
		             x,
		             &y1_pack,
		             &a1_pack,
		             cntx,
		             bli_cntl_sub_ger( cntl ) );

		// Copy/unpack A1 (if A1 was packed).
		bli_unpackm_int( &a1_pack, &a1,
		                 cntx, bli_cntl_sub_unpackm_a( cntl ),
                         &BLIS_PACKM_SINGLE_THREADED );
	}

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
	bli_packm_release( &a1_pack, bli_cntl_sub_packm_a( cntl ) );
	bli_packv_release( &y1_pack, bli_cntl_sub_packv_y( cntl ) );
}
Esempio n. 4
0
void bli_trmm_blk_var2f( obj_t*  a,
                         obj_t*  b,
                         obj_t*  c,
                         trmm_t* cntl )
{
    obj_t a_pack;
    obj_t b1, b1_pack;
    obj_t c1, c1_pack;

    dim_t i;
    dim_t b_alg;
    dim_t n_trans;

    // Initialize all pack objects that are passed into packm_init().
    bli_obj_init_pack( &a_pack );
    bli_obj_init_pack( &b1_pack );
    bli_obj_init_pack( &c1_pack );

    // Query dimension in partitioning direction.
    n_trans = bli_obj_width_after_trans( *b );

    // Scale C by beta (if instructed).
    bli_scalm_int( &BLIS_ONE,
                   c,
                   cntl_sub_scalm( cntl ) );

    // Initialize object for packing A.
    bli_packm_init( a, &a_pack,
                    cntl_sub_packm_a( cntl ) );

    // Pack A (if instructed).
    bli_packm_int( a, &a_pack,
                   cntl_sub_packm_a( cntl ) );

    // Partition along the n dimension.
    for ( i = 0; i < n_trans; i += b_alg )
    {
        // Determine the current algorithmic blocksize.
        b_alg = bli_determine_blocksize_f( i, n_trans, b,
                                           cntl_blocksize( cntl ) );

        // Acquire partitions for B1 and C1.
        bli_acquire_mpart_l2r( BLIS_SUBPART1,
                               i, b_alg, b, &b1 );
        bli_acquire_mpart_l2r( BLIS_SUBPART1,
                               i, b_alg, c, &c1 );

        // Initialize objects for packing A1 and B1.
        bli_packm_init( &b1, &b1_pack,
                        cntl_sub_packm_b( cntl ) );
        bli_packm_init( &c1, &c1_pack,
                        cntl_sub_packm_c( cntl ) );

        // Pack B1 (if instructed).
        bli_packm_int( &b1, &b1_pack,
                       cntl_sub_packm_b( cntl ) );

        // Pack C1 (if instructed).
        bli_packm_int( &c1, &c1_pack,
                       cntl_sub_packm_c( cntl ) );

        // Perform trmm subproblem.
        bli_trmm_int( &BLIS_ONE,
                      &a_pack,
                      &b1_pack,
                      &BLIS_ONE,
                      &c1_pack,
                      cntl_sub_trmm( cntl ) );

        // Unpack C1 (if C1 was packed).
        bli_unpackm_int( &c1_pack, &c1,
                         cntl_sub_unpackm_c( cntl ) );
    }

    // If any packing buffers were acquired within packm, release them back
    // to the memory manager.
    bli_obj_release_pack( &a_pack );
    bli_obj_release_pack( &b1_pack );
    bli_obj_release_pack( &c1_pack );
}
Esempio n. 5
0
void bli_gemm_blk_var3f( obj_t*  a,
                         obj_t*  b,
                         obj_t*  c,
                         gemm_t* cntl )
{
	obj_t  a1, a1_pack;
	obj_t  b1, b1_pack;
	obj_t  c_pack;

	dim_t  i;
	dim_t  b_alg;
	dim_t  k_trans;

	// Initialize all pack objects that are passed into packm_init().
	bli_obj_init_pack( &a1_pack );
	bli_obj_init_pack( &b1_pack );
	bli_obj_init_pack( &c_pack );

	// Query dimension in partitioning direction.
	k_trans = bli_obj_width_after_trans( *a );

	// Scale C by beta (if instructed).
	bli_scalm_int( &BLIS_ONE,
	               c,
	               cntl_sub_scalm( cntl ) );

	// Initialize object for packing C.
	bli_packm_init( c, &c_pack,
	                cntl_sub_packm_c( cntl ) );

	// Pack C (if instructed).
	bli_packm_int( c, &c_pack,
	               cntl_sub_packm_c( cntl ) );

	// Partition along the k dimension.
	for ( i = 0; i < k_trans; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		// NOTE: Use of b (for execution datatype) is intentional!
		// This causes the right blocksize to be used if c and a are
		// complex and b is real.
		b_alg = bli_determine_blocksize_f( i, k_trans, b,
		                                   cntl_blocksize( cntl ) );

		// Acquire partitions for A1 and B1.
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, a, &a1 );
		bli_acquire_mpart_t2b( BLIS_SUBPART1,
		                       i, b_alg, b, &b1 );

		// Initialize objects for packing A1 and B1.
		bli_packm_init( &a1, &a1_pack,
		                cntl_sub_packm_a( cntl ) );
		bli_packm_init( &b1, &b1_pack,
		                cntl_sub_packm_b( cntl ) );

		// Pack A1 (if instructed).
		bli_packm_int( &a1, &a1_pack,
		               cntl_sub_packm_a( cntl ) );

		// Pack B1 (if instructed).
		bli_packm_int( &b1, &b1_pack,
		               cntl_sub_packm_b( cntl ) );

		// Perform gemm subproblem.
		bli_gemm_int( &BLIS_ONE,
		              &a1_pack,
		              &b1_pack,
		              &BLIS_ONE,
		              &c_pack,
		              cntl_sub_gemm( cntl ) );

		// This variant executes multiple rank-k updates. Therefore, if the
		// internal beta scalar on matrix C is non-zero, we must use it
		// only for the first iteration (and then BLIS_ONE for all others).
		// And since c_pack is a local obj_t, we can simply overwrite the
		// internal beta scalar with BLIS_ONE once it has been used in the
		// first iteration.
		if ( i == 0 ) bli_obj_scalar_reset( &c_pack );
	}

	// Unpack C (if C was packed).
	bli_unpackm_int( &c_pack, c,
	                 cntl_sub_unpackm_c( cntl ) );

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
	bli_obj_release_pack( &a1_pack );
	bli_obj_release_pack( &b1_pack );
	bli_obj_release_pack( &c_pack );
}
Esempio n. 6
0
void bli_trsm_l_blk_var4( obj_t*  alpha,
                          obj_t*  a,
                          obj_t*  b,
                          obj_t*  beta,
                          obj_t*  c,
                          trsm_t* cntl )
{
    obj_t a1, a1_pack;
    obj_t b_pack;
    obj_t c1;

    dim_t i;
    dim_t bm_alg;
    dim_t m_trans;
    dim_t offB;

    // Initialize all pack objects that are passed into packm_init().
    bli_obj_init_pack( &a1_pack );
    bli_obj_init_pack( &b_pack );

    // Query dimension in partitioning direction.
    m_trans = bli_obj_length_after_trans( *a );

    // Use the diagonal offset of A to skip over the zero region.
    offB = bli_abs( bli_obj_diag_offset_after_trans( *a ) );

    // Initialize object for packing B.
    bli_packm_init( b, &b_pack,
                    cntl_sub_packm_b( cntl ) );

    // Fuse the first iteration with incremental packing and computation.
    {
        obj_t b_inc, b_pack_inc;
        obj_t c1_inc;

        dim_t j;
        dim_t bn_inc;
        dim_t n_trans;

        // Query dimension in partitioning direction.
        n_trans = bli_obj_width( b_pack );

        // Determine the current algorithmic blocksize.
        bm_alg = bli_determine_blocksize_f( offB, m_trans, a,
                                            cntl_blocksize( cntl ) );

        // Acquire partitions for A1 and C1.
        bli_acquire_mpart_t2b( BLIS_SUBPART1,
                               offB, bm_alg, a, &a1 );
        bli_acquire_mpart_t2b( BLIS_SUBPART1,
                               offB, bm_alg, c, &c1 );

        // Initialize objects for packing A1 and C1.
        bli_packm_init( &a1, &a1_pack, cntl_sub_packm_a( cntl ) );

        // Pack A1 and scale by alpha (if instructed).
        bli_packm_int( alpha, &a1, &a1_pack, cntl_sub_packm_a( cntl ) );

        // Partition along the n dimension.
        for ( j = 0; j < n_trans; j += bn_inc )
        {
            // Determine the current incremental packing blocksize.
            bn_inc = bli_determine_blocksize_f( j, n_trans, b,
                                                cntl_blocksize_aux( cntl ) );

            // Acquire partitions.
            bli_acquire_mpart_l2r( BLIS_SUBPART1,
                                   j, bn_inc, b, &b_inc );
            bli_acquire_mpart_l2r( BLIS_SUBPART1,
                                   j, bn_inc, &b_pack, &b_pack_inc );
            bli_acquire_mpart_l2r( BLIS_SUBPART1,
                                   j, bn_inc, &c1, &c1_inc );

            // Pack B1 and scale by alpha (if instructed).
            bli_packm_int( alpha, &b_inc, &b_pack_inc, cntl_sub_packm_b( cntl ) );

            // Perform trsm subproblem.
            bli_trsm_int( BLIS_LEFT,
                          alpha,
                          &a1_pack,
                          &b_pack_inc,
                          beta,
                          &c1_inc,
                          cntl_sub_trsm( cntl ) );
        }

        // Unpack B to the corresponding region of C. (Note that B and C1 are
        // conformal since A1 is square.)
        //bli_unpackm_int( &b_pack, &c1,
        //                 cntl_sub_unpackm_c( cntl ) );
    }

    // Partition along the remaining portion of the m dimension.
    for ( i = offB + bm_alg; i < m_trans; i += bm_alg )
    {
        // Determine the current algorithmic blocksize.
        bm_alg = bli_determine_blocksize_f( i, m_trans, a,
                                            cntl_blocksize( cntl ) );

        // Acquire partitions for A1 and C1.
        bli_acquire_mpart_t2b( BLIS_SUBPART1,
                               i, bm_alg, a, &a1 );
        bli_acquire_mpart_t2b( BLIS_SUBPART1,
                               i, bm_alg, c, &c1 );

        // Initialize object for packing A1.
        bli_packm_init( &a1, &a1_pack,
                        cntl_sub_packm_a( cntl ) );

        // Pack A1 and scale by alpha (if instructed).
        bli_packm_int( alpha,
                       &a1, &a1_pack,
                       cntl_sub_packm_a( cntl ) );

        // Perform trsm subproblem.
        if ( bli_obj_intersects_diag( a1_pack ) )
            bli_trsm_int( BLIS_LEFT,
                          alpha,
                          &a1_pack,
                          &b_pack,
                          beta,
                          &c1,
                          cntl_sub_trsm( cntl ) );
        else
            bli_gemm_int( &BLIS_MINUS_ONE,
                          &a1_pack,
                          &b_pack,
                          &BLIS_ONE,
                          &c1,
                          cntl_sub_gemm( cntl ) );
    }

    // If any packing buffers were acquired within packm, release them back
    // to the memory manager.
    bli_obj_release_pack( &a1_pack );
    bli_obj_release_pack( &b_pack );
}
Esempio n. 7
0
void libblis_test_axpyf_check( obj_t*  alpha,
                               obj_t*  a,
                               obj_t*  x,
                               obj_t*  y,
                               obj_t*  y_orig,
                               double* resid )
{
	num_t  dt      = bli_obj_datatype( *y );
	num_t  dt_real = bli_obj_datatype_proj_to_real( *y );

	dim_t  m       = bli_obj_vector_dim( *y );
	dim_t  b_n     = bli_obj_width( *a );

	dim_t  i;

	obj_t  a1, chi1, v;
	obj_t  alpha_chi1;
	obj_t  norm;

	double junk;

	//
	// Pre-conditions:
	// - a is randomized.
	// - x is randomized.
	// - y is randomized.
	// Note:
	// - alpha should have a non-zero imaginary component in the complex
	//   cases in order to more fully exercise the implementation.
	//
	// Under these conditions, we assume that the implementation for
	//
	//   y := y_orig + alpha * conja(A) * conjx(x)
	//
	// is functioning correctly if
	//
	//   normf( y - v )
	//
	// is negligible, where v contains y as computed by repeated calls to
	// axpyv.
	//

	bli_obj_scalar_init_detached( dt_real, &norm );
	bli_obj_scalar_init_detached( dt,      &alpha_chi1 );

	bli_obj_create( dt, m,   1, 0, 0, &v );

	bli_copyv( y_orig, &v );

	for ( i = 0; i < b_n; ++i )
	{
		bli_acquire_mpart_l2r( BLIS_SUBPART1, i, 1, a, &a1 );
		bli_acquire_vpart_f2b( BLIS_SUBPART1, i, 1, x, &chi1 );

		bli_copysc( &chi1, &alpha_chi1 );
		bli_mulsc( alpha, &alpha_chi1 );

		bli_axpyv( &alpha_chi1, &a1, &v );
	}

	bli_subv( y, &v );
	bli_normfv( &v, &norm );
	bli_getsc( &norm, resid, &junk );

	bli_obj_free( &v );
}
Esempio n. 8
0
void bli_herk_blk_var3f( obj_t*  a,
                         obj_t*  ah,
                         obj_t*  c,
                         herk_t* cntl,
                         herk_thrinfo_t* thread )
{
    obj_t  c_pack_s;
    obj_t  a1_pack_s, ah1_pack_s;

	obj_t  a1, ah1;
    obj_t* a1_pack = NULL;
    obj_t* ah1_pack = NULL;
	obj_t* c_pack = NULL;

	dim_t  i;
	dim_t  b_alg;
	dim_t  k_trans;

    if( thread_am_ochief( thread ) ) {
        // Initialize object for packing C.
	    bli_obj_init_pack( &c_pack_s );
        bli_packm_init( c, &c_pack_s,
                        cntl_sub_packm_c( cntl ) );
        
        // Scale C by beta (if instructed).
        bli_scalm_int( &BLIS_ONE,
                       c,
                       cntl_sub_scalm( cntl ) );
    }
    c_pack = thread_obroadcast( thread, &c_pack_s );

	// Initialize all pack objects that are passed into packm_init().
    if( thread_am_ichief( thread ) ) {
        bli_obj_init_pack( &a1_pack_s );
        bli_obj_init_pack( &ah1_pack_s );
    }
    a1_pack = thread_ibroadcast( thread, &a1_pack_s );
    ah1_pack = thread_ibroadcast( thread, &ah1_pack_s );

	// Pack C (if instructed).
	bli_packm_int( c, c_pack,
	               cntl_sub_packm_c( cntl ),
                   herk_thread_sub_opackm( thread ) );

	// Query dimension in partitioning direction.
	k_trans = bli_obj_width_after_trans( *a );

	// Partition along the k dimension.
	for ( i = 0; i < k_trans; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		b_alg = bli_determine_blocksize_f( i, k_trans, a,
		                                   cntl_blocksize( cntl ) );

		// Acquire partitions for A1 and A1'.
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, a, &a1 );
		bli_acquire_mpart_t2b( BLIS_SUBPART1,
		                       i, b_alg, ah, &ah1 );

		// Initialize objects for packing A1 and A1'.
        if( thread_am_ichief( thread ) ) {
            bli_packm_init( &a1, a1_pack,
                            cntl_sub_packm_a( cntl ) );
            bli_packm_init( &ah1, ah1_pack,
                            cntl_sub_packm_b( cntl ) );
        }
        thread_ibarrier( thread );

		// Pack A1 (if instructed).
		bli_packm_int( &a1, a1_pack,
		               cntl_sub_packm_a( cntl ),
                       herk_thread_sub_ipackm( thread ) );

		// Pack B1 (if instructed).
		bli_packm_int( &ah1, ah1_pack,
		               cntl_sub_packm_b( cntl ),
                       herk_thread_sub_ipackm( thread ) );

		// Perform herk subproblem.
		bli_herk_int( &BLIS_ONE,
		              a1_pack,
		              ah1_pack,
		              &BLIS_ONE,
		              c_pack,
		              cntl_sub_herk( cntl ),
                      herk_thread_sub_herk( thread ) );

        // This variant executes multiple rank-k updates. Therefore, if the
        // internal beta scalar on matrix C is non-zero, we must use it
        // only for the first iteration (and then BLIS_ONE for all others).
        // And since c_pack is a local obj_t, we can simply overwrite the
        // internal beta scalar with BLIS_ONE once it has been used in the
        // first iteration.
        if ( i == 0 ) thread_ibarrier( thread );
        if ( i == 0 && thread_am_ichief( thread ) ) bli_obj_scalar_reset( c_pack );

	}

    thread_obarrier( thread );
    
	// Unpack C (if C was packed).
    bli_unpackm_int( c_pack, c,
                     cntl_sub_unpackm_c( cntl ),
                     herk_thread_sub_opackm( thread ) );

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
    if( thread_am_ochief( thread ) ) {
	    bli_obj_release_pack( c_pack );
    }
    if( thread_am_ichief( thread ) ) {
        bli_obj_release_pack( a1_pack );
        bli_obj_release_pack( ah1_pack );
    }
}
Esempio n. 9
0
void bli_trmm_lu_blk_var4( obj_t*  alpha,
                           obj_t*  a,
                           obj_t*  b,
                           obj_t*  beta,
                           obj_t*  c,
                           trmm_t* cntl )
{
    obj_t a1, a1_pack;
    obj_t b_pack;
    obj_t c1, c1_pack;

    dim_t i;
    dim_t bm_alg;
    dim_t mT_trans;

    // Initialize all pack objects that are passed into packm_init().
    bli_obj_init_pack( &a1_pack );
    bli_obj_init_pack( &b_pack );
    bli_obj_init_pack( &c1_pack );

    // Query dimension in partitioning direction. Use the diagonal offset
    // to stop short of the zero region.
    mT_trans = bli_abs( bli_obj_diag_offset_after_trans( *a ) ) +
               bli_obj_width_after_trans( *a );

    // Scale C by beta (if instructed).
    bli_scalm_int( beta,
                   c,
                   cntl_sub_scalm( cntl ) );

    // Initialize object for packing B.
    bli_packm_init( b, &b_pack,
                    cntl_sub_packm_b( cntl ) );

    // Fuse the first iteration with incremental packing and computation.
    {
        obj_t b_inc, b_pack_inc;
        obj_t c1_pack_inc;

        dim_t j;
        dim_t bn_inc;
        dim_t n_trans;

        // Query dimension in partitioning direction.
        n_trans = bli_obj_width( b_pack );

        // Determine the current algorithmic blocksize.
        bm_alg = bli_determine_blocksize_f( 0, mT_trans, a,
                                            cntl_blocksize( cntl ) );

        // Acquire partitions for A1 and C1.
        bli_acquire_mpart_t2b( BLIS_SUBPART1,
                               0, bm_alg, a, &a1 );
        bli_acquire_mpart_t2b( BLIS_SUBPART1,
                               0, bm_alg, c, &c1 );

        // Initialize objects for packing A1 and C1.
        bli_packm_init( &a1, &a1_pack, cntl_sub_packm_a( cntl ) );
        bli_packm_init( &c1, &c1_pack, cntl_sub_packm_c( cntl ) );

        // Pack A1 and scale by alpha (if instructed).
        bli_packm_int( alpha, &a1, &a1_pack, cntl_sub_packm_a( cntl ) );

        // Pack C1 and scale by beta (if instructed).
        bli_packm_int( beta,  &c1, &c1_pack, cntl_sub_packm_c( cntl ) );

        // Partition along the n dimension.
        for ( j = 0; j < n_trans; j += bn_inc )
        {
            // Determine the current incremental packing blocksize.
            bn_inc = bli_determine_blocksize_f( j, n_trans, b,
                                                cntl_blocksize_aux( cntl ) );

            // Acquire partitions.
            bli_acquire_mpart_l2r( BLIS_SUBPART1,
                                   j, bn_inc, b, &b_inc );
            bli_acquire_mpart_l2r( BLIS_SUBPART1,
                                   j, bn_inc, &b_pack, &b_pack_inc );
            bli_acquire_mpart_l2r( BLIS_SUBPART1,
                                   j, bn_inc, &c1_pack, &c1_pack_inc );

            // Pack B1 and scale by alpha (if instructed).
            bli_packm_int( alpha, &b_inc, &b_pack_inc, cntl_sub_packm_b( cntl ) );

            // Perform trmm subproblem.
            bli_trmm_int( BLIS_LEFT,
                          alpha,
                          &a1_pack,
                          &b_pack_inc,
                          beta,
                          &c1_pack_inc,
                          cntl_sub_trmm( cntl ) );
        }

        // Unpack C1 (if C1 was packed).
        bli_unpackm_int( &c1_pack, &c1, cntl_sub_unpackm_c( cntl ) );
    }


    // Partition along the remaining portion of the m dimension.
    for ( i = bm_alg; i < mT_trans; i += bm_alg )
    {
        // Determine the current algorithmic blocksize.
        bm_alg = bli_determine_blocksize_f( i, mT_trans, a,
                                            cntl_blocksize( cntl ) );

        // Acquire partitions for A1 and C1.
        bli_acquire_mpart_t2b( BLIS_SUBPART1,
                               i, bm_alg, a, &a1 );
        bli_acquire_mpart_t2b( BLIS_SUBPART1,
                               i, bm_alg, c, &c1 );

        // Initialize objects for packing A1 and C1.
        bli_packm_init( &a1, &a1_pack,
                        cntl_sub_packm_a( cntl ) );
        bli_packm_init( &c1, &c1_pack,
                        cntl_sub_packm_c( cntl ) );

        // Pack A1 and scale by alpha (if instructed).
        bli_packm_int( alpha,
                       &a1, &a1_pack,
                       cntl_sub_packm_a( cntl ) );

        // Pack C1 and scale by beta (if instructed).
        bli_packm_int( beta,
                       &c1, &c1_pack,
                       cntl_sub_packm_c( cntl ) );

        // Perform trmm subproblem.
        if ( bli_obj_intersects_diag( a1_pack ) )
            bli_trmm_int( BLIS_LEFT,
                          alpha,
                          &a1_pack,
                          &b_pack,
                          beta,
                          &c1_pack,
                          cntl_sub_trmm( cntl ) );
        else
            bli_gemm_int( alpha,
                          &a1_pack,
                          &b_pack,
                          &BLIS_ONE,
                          &c1_pack,
                          cntl_sub_gemm( cntl ) );

        // Unpack C1 (if C1 was packed).
        bli_unpackm_int( &c1_pack, &c1,
                         cntl_sub_unpackm_c( cntl ) );
    }

    // If any packing buffers were acquired within packm, release them back
    // to the memory manager.
    bli_obj_release_pack( &a1_pack );
    bli_obj_release_pack( &b_pack );
    bli_obj_release_pack( &c1_pack );
}
Esempio n. 10
0
void bli_gemm_blk_var2( obj_t*  alpha,
                        obj_t*  a,
                        obj_t*  b,
                        obj_t*  beta,
                        obj_t*  c,
                        gemm_t* cntl )
{
	obj_t a_pack_s;
	obj_t b1_pack_s;
	obj_t c1_pack_s;

    obj_t  b1, c1;
    obj_t* a_pack   = NULL;
    obj_t* b1_pack  = NULL;
    obj_t* c1_pack  = NULL;

	dim_t i;
	dim_t b_alg;
	dim_t n_trans;
    
    dim_t num_groups = bli_gemm_num_thread_groups( cntl->thread_info );
    dim_t group_id   = bli_gemm_group_id( cntl->thread_info );

    if( bli_gemm_am_a_master( cntl->thread_info ) ) {
        // Initialize object for packing A.
        bli_obj_init_pack( &a_pack_s );
        bli_packm_init( a, &a_pack_s,
                        cntl_sub_packm_a( cntl ) );

    }
    a_pack = bli_gemm_broadcast_a( cntl->thread_info, &a_pack_s );

	// Pack A and scale by alpha (if instructed).
	bli_packm_int( alpha,
	               a, a_pack,
	               cntl_sub_packm_a( cntl ) );

    bli_gemm_a_barrier( cntl->thread_info );

	if( bli_gemm_am_b_master( cntl->thread_info )) {
        bli_obj_init_pack( &b1_pack_s );
    }
    b1_pack  = bli_gemm_broadcast_b( cntl->thread_info, &b1_pack_s );

    if( bli_gemm_am_c_master( cntl->thread_info )) {
        bli_obj_init_pack( &c1_pack_s );

        // Scale C by beta (if instructed).
        bli_scalm_int( beta,
                       c,
                       cntl_sub_scalm( cntl ) );
    }
    c1_pack  = bli_gemm_broadcast_c( cntl->thread_info, &c1_pack_s );


	// Query dimension in partitioning direction.
	n_trans = bli_obj_width_after_trans( *b );
    dim_t n_pt = n_trans / num_groups;
    n_pt = (n_pt * num_groups < n_trans) ? n_pt + 1 : n_pt;
    n_pt = (n_pt % 8 == 0) ? n_pt : n_pt + 8 - (n_pt % 8);
    dim_t start = group_id * n_pt;
    dim_t end = bli_min( start + n_pt, n_trans );

	// Partition along the n dimension.
	for ( i = start; i < end; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		// NOTE: Use of b (for execution datatype) is intentional!
		// This causes the right blocksize to be used if c and a are
		// complex and b is real.
		b_alg = bli_determine_blocksize_f( i, end, b,
		                                   cntl_blocksize( cntl ) );

        // Acquire partitions for C1 
        bli_acquire_mpart_l2r( BLIS_SUBPART1,
                               i, b_alg, c, &c1 );
        // Acquire partitions for B1 
        bli_acquire_mpart_l2r( BLIS_SUBPART1,
                               i, b_alg, b, &b1 );

        if( bli_gemm_am_b_master( cntl->thread_info )) {
            // Initialize objects for packing B1 
            bli_packm_init( &b1, &b1_pack_s,
                            cntl_sub_packm_b( cntl ) );
        }

        if( bli_gemm_am_c_master( cntl->thread_info )) {
            // Initialize objects for packing C1 
            bli_packm_init( &c1, &c1_pack_s,
                            cntl_sub_packm_c( cntl ) );
        }

        bli_gemm_b_barrier( cntl->thread_info );
        bli_gemm_c_barrier( cntl->thread_info );
        
		// Pack B1 and scale by alpha (if instructed).
		bli_packm_int( alpha,
		               &b1, b1_pack,
		               cntl_sub_packm_b( cntl ) );

		// Pack C1 and scale by beta (if instructed).
		bli_packm_int( beta,
		               &c1, c1_pack,
		               cntl_sub_packm_c( cntl ) );

        // Packing must be done before computation
        bli_gemm_b_barrier( cntl->thread_info );
        bli_gemm_c_barrier( cntl->thread_info );

		// Perform gemm subproblem.
		bli_gemm_int( alpha,
		              a_pack,
		              b1_pack,
		              beta,
		              c1_pack,
		              cntl_sub_gemm( cntl ) );

		// Unpack C1 (if C1 was packed).
		bli_unpackm_int( c1_pack, &c1,
		                 cntl_sub_unpackm_c( cntl ) );
	}

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
    bli_gemm_a_barrier( cntl->thread_info );
    if( bli_gemm_am_a_master( cntl->thread_info ))
	    bli_obj_release_pack( &a_pack_s );
    bli_gemm_b_barrier( cntl->thread_info );
    if( bli_gemm_am_b_master( cntl->thread_info )) {
        bli_obj_release_pack( &b1_pack_s );
    }
    bli_gemm_c_barrier( cntl->thread_info );
    if( bli_gemm_am_c_master( cntl->thread_info )) {
        bli_obj_release_pack( &c1_pack_s );
    }
}
Esempio n. 11
0
void bli_trsm_u_blk_var4( obj_t*  alpha,
                          obj_t*  a,
                          obj_t*  b,
                          obj_t*  beta,
                          obj_t*  c,
                          trsm_t* cntl )
{
	obj_t a1, a1_pack;
	obj_t b_pack;
	obj_t c1;

	dim_t i;
	dim_t bm_alg;
	dim_t m_trans;

	// Initialize all pack objects that are passed into packm_init().
	bli_obj_init_pack( &a1_pack );
	bli_obj_init_pack( &b_pack );

	// Query dimension in partitioning direction.
	m_trans = bli_obj_length_after_trans( *a );

	// Initialize object for packing B.
	bli_packm_init( b, &b_pack,
	                cntl_sub_packm_b( cntl ) );

	// Find the offset to the first non-zero block of A.
	for ( i = 0; i < m_trans; i += bm_alg )
	{
		// Determine the current algorithmic blocksize.
		bm_alg = bli_determine_blocksize_b( i, m_trans, a,
		                                    cntl_blocksize( cntl ) );

		// Acquire partitions for A1 and C1.
		bli_acquire_mpart_b2t( BLIS_SUBPART1,
		                       i, bm_alg, a, &a1 );

		if ( !bli_obj_is_zeros( a1 ) ) break;
	}

	// Fuse the first iteration with incremental packing and computation.
	{
		obj_t b_inc, b_pack_inc;
		obj_t c1_inc;

		dim_t j;
		dim_t bn_inc;
		dim_t n_trans;

		// Query dimension in partitioning direction.
		n_trans = bli_obj_width( b_pack );

		// Determine the current algorithmic blocksize.
		bm_alg = bli_determine_blocksize_b( i, m_trans, a,
		                                    cntl_blocksize( cntl ) );

		// Acquire partitions for A1 and C1.
		bli_acquire_mpart_b2t( BLIS_SUBPART1,
		                       i, bm_alg, a, &a1 );
		bli_acquire_mpart_b2t( BLIS_SUBPART1,
		                       i, bm_alg, c, &c1 );

		// Initialize objects for packing A1 and C1.
		bli_packm_init( &a1, &a1_pack, cntl_sub_packm_a( cntl ) );

		// Pack A1 and scale by alpha (if instructed).
		bli_packm_int( alpha, &a1, &a1_pack, cntl_sub_packm_a( cntl ) );

		// Partition along the n dimension.
		for ( j = 0; j < n_trans; j += bn_inc )
		{
			// Determine the current incremental packing blocksize.
			bn_inc = bli_determine_blocksize_f( j, n_trans, b,
			                                    cntl_blocksize_aux( cntl ) );

			// Acquire partitions.
			bli_acquire_mpart_l2r( BLIS_SUBPART1,
			                       j, bn_inc, b, &b_inc );
			bli_acquire_mpart_l2r( BLIS_SUBPART1,
			                       j, bn_inc, &b_pack, &b_pack_inc );
			bli_acquire_mpart_l2r( BLIS_SUBPART1,
			                       j, bn_inc, &c1, &c1_inc );

			// Pack B1 and scale by alpha (if instructed).
			bli_packm_int( alpha, &b_inc, &b_pack_inc, cntl_sub_packm_b( cntl ) );

			// Perform trsm subproblem.
			bli_trsm_int( BLIS_LEFT,
			              alpha,
			              &a1_pack,
			              &b_pack_inc,
			              beta,
			              &c1_inc,
			              cntl_sub_trsm( cntl ) );
		}
	}

	// Partition along the remaining portion of the m dimension.
	for ( i = i + bm_alg; i < m_trans; i += bm_alg )
	{
		// Determine the current algorithmic blocksize.
		bm_alg = bli_determine_blocksize_b( i, m_trans, a,
		                                    cntl_blocksize( cntl ) );

		// Acquire partitions for A1 and C1.
		bli_acquire_mpart_b2t( BLIS_SUBPART1,
		                       i, bm_alg, a, &a1 );
		bli_acquire_mpart_b2t( BLIS_SUBPART1,
		                       i, bm_alg, c, &c1 );

		// Initialize object for packing A1.
		bli_packm_init( &a1, &a1_pack,
		                cntl_sub_packm_a( cntl ) );

		// Pack A1 and scale by alpha (if instructed).
		bli_packm_int( alpha,
		               &a1, &a1_pack,
		               cntl_sub_packm_a( cntl ) );

		if ( bli_obj_intersects_diag( a1_pack ) )
			bli_trsm_int( BLIS_LEFT,
			              alpha,
			              &a1_pack,
			              &b_pack,
			              beta,
			              &c1,
			              cntl_sub_trsm( cntl ) );
		else
			bli_gemm_int( &BLIS_MINUS_ONE,
			              &a1_pack,
			              &b_pack,
			              &BLIS_ONE,
			              &c1,
			              cntl_sub_gemm( cntl ) );
	}

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
	bli_obj_release_pack( &a1_pack );
	bli_obj_release_pack( &b_pack );
}
Esempio n. 12
0
void bli_trsm_blk_var3f( obj_t*  a,
                         obj_t*  b,
                         obj_t*  c,
                         trsm_t* cntl,
                         trsm_thrinfo_t* thread )
{
    obj_t  c_pack_s;
    obj_t  a1_pack_s, b1_pack_s;

    obj_t  a1, b1;
    obj_t* a1_pack = NULL;
    obj_t* b1_pack = NULL;
    obj_t* c_pack = NULL;

	dim_t  i;
	dim_t  b_alg;
	dim_t  k_trans;

	// Initialize pack objects for C that are passed into packm_init().
    if( thread_am_ochief( thread ) ) {
	    bli_obj_init_pack( &c_pack_s );

        // Initialize object for packing C.
        bli_packm_init( c, &c_pack_s,
                        cntl_sub_packm_c( cntl ) );

        // Scale C by beta (if instructed).
        bli_scalm_int( &BLIS_ONE,
                       c,
                       cntl_sub_scalm( cntl ) );
    }
    c_pack = thread_obroadcast( thread, &c_pack_s );

    if( thread_am_ichief( thread ) ) {
        bli_obj_init_pack( &a1_pack_s );
        bli_obj_init_pack( &b1_pack_s );
    }
    a1_pack = thread_ibroadcast( thread, &a1_pack_s );
    b1_pack = thread_ibroadcast( thread, &b1_pack_s );

	// Pack C (if instructed).
	bli_packm_int( c, c_pack,
	               cntl_sub_packm_c( cntl ),
                   trsm_thread_sub_opackm( thread ) );

	// Query dimension in partitioning direction.
	k_trans = bli_obj_width_after_trans( *a );

	// Partition along the k dimension.
	for ( i = 0; i < k_trans; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		// NOTE: We call a trsm-specific function to determine the kc
		// blocksize so that we can implement the "nudging" of kc to be
		// a multiple of mr, as needed.
		b_alg = bli_trsm_determine_kc_f( i, k_trans, b,
		                                 cntl_blocksize( cntl ) );

		// Acquire partitions for A1 and B1.
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, a, &a1 );
		bli_acquire_mpart_t2b( BLIS_SUBPART1,
		                       i, b_alg, b, &b1 );

		// Initialize objects for packing A1 and B1.
        if( thread_am_ichief( thread ) ) {
            bli_packm_init( &a1, a1_pack,
                            cntl_sub_packm_a( cntl ) );
            bli_packm_init( &b1, b1_pack,
                            cntl_sub_packm_b( cntl ) );
        }
        thread_ibarrier( thread );

		// Pack A1 (if instructed).
		bli_packm_int( &a1, a1_pack,
		               cntl_sub_packm_a( cntl ),
                       trsm_thread_sub_ipackm( thread ) );

		// Pack B1 (if instructed).
		bli_packm_int( &b1, b1_pack,
		               cntl_sub_packm_b( cntl ),
                       trsm_thread_sub_ipackm( thread ) );

		// Perform trsm subproblem.
		bli_trsm_int( &BLIS_ONE,
		              a1_pack,
		              b1_pack,
		              &BLIS_ONE,
		              c_pack,
		              cntl_sub_trsm( cntl ),
                      trsm_thread_sub_trsm( thread ) );

		// This variant executes multiple rank-k updates. Therefore, if the
		// internal alpha scalars on A/B and C are non-zero, we must ensure
		// that they are only used in the first iteration.
        thread_ibarrier( thread );
		if ( i == 0 && thread_am_ichief( thread ) ) { 
            bli_obj_scalar_reset( a );
            bli_obj_scalar_reset( b );
            bli_obj_scalar_reset( c_pack ); 
        }
	}

    thread_obarrier( thread );

	// Unpack C (if C was packed).
    bli_unpackm_int( c_pack, c,
                     cntl_sub_unpackm_c( cntl ),
                     trsm_thread_sub_opackm( thread ) );

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
    if( thread_am_ochief( thread ) ) {
	    bli_packm_release( c_pack, cntl_sub_packm_c( cntl ) );
    }
    if( thread_am_ichief( thread ) ) {
        bli_packm_release( a1_pack, cntl_sub_packm_a( cntl ) );
        bli_packm_release( b1_pack, cntl_sub_packm_b( cntl ) );
    }
}
Esempio n. 13
0
void bli_gemm_blk_var4( obj_t*  a,
                        obj_t*  b,
                        obj_t*  c,
                        gemm_t* cntl )
{
	obj_t a1, a1_pack;
	obj_t b_pack;
	obj_t c1, c1_pack;

	dim_t i;
	dim_t bm_alg;
	dim_t m_trans;

	// Initialize all pack objects that are passed into packm_init().
	bli_obj_init_pack( &a1_pack );
	bli_obj_init_pack( &b_pack );
	bli_obj_init_pack( &c1_pack );

	// Query dimension in partitioning direction.
	m_trans = bli_obj_length_after_trans( *a );

	// Scale C by beta (if instructed).
	bli_scalm_int( &BLIS_ONE,
	               c,
	               cntl_sub_scalm( cntl ) );

	// Initialize object for packing B.
	bli_packm_init( b, &b_pack,
	                cntl_sub_packm_b( cntl ) );

	// Fuse the first iteration with incremental packing and computation.
	{
		obj_t b_inc, b_pack_inc;
		obj_t c1_pack_inc;

		dim_t j;
		dim_t bn_inc;
		dim_t n_trans;

		// Query dimension in partitioning direction.
		n_trans = bli_obj_width( b_pack );

		// Determine the current algorithmic blocksize.
		bm_alg = bli_determine_blocksize_f( 0, m_trans, a,
		                                    cntl_blocksize( cntl ) );

		// Acquire partitions for A1 and C1.
		bli_acquire_mpart_t2b( BLIS_SUBPART1,
		                       0, bm_alg, a, &a1 );
		bli_acquire_mpart_t2b( BLIS_SUBPART1,
		                       0, bm_alg, c, &c1 );

		// Initialize objects for packing A1 and C1.
		bli_packm_init( &a1, &a1_pack, cntl_sub_packm_a( cntl ) );
		bli_packm_init( &c1, &c1_pack, cntl_sub_packm_c( cntl ) );

		// Pack A1 (if instructed).
		bli_packm_int( &a1, &a1_pack, cntl_sub_packm_a( cntl ) );

		// Pack C1 (if instructed).
		bli_packm_int( &c1, &c1_pack, cntl_sub_packm_c( cntl ) );

		// Partition along the n dimension.
		for ( j = 0; j < n_trans; j += bn_inc )
		{
			// Determine the current incremental packing blocksize.
			bn_inc = bli_determine_blocksize_f( j, n_trans, b,
			                                    cntl_blocksize_aux( cntl ) );

			// Acquire partitions.
			bli_acquire_mpart_l2r( BLIS_SUBPART1,
			                       j, bn_inc, b, &b_inc );
			bli_acquire_mpart_l2r( BLIS_SUBPART1,
			                       j, bn_inc, &b_pack, &b_pack_inc );
			bli_acquire_mpart_l2r( BLIS_SUBPART1,
			                       j, bn_inc, &c1_pack, &c1_pack_inc );

			// Pack B1 (if instructed).
			bli_packm_int( &b_inc, &b_pack_inc, cntl_sub_packm_b( cntl ) );

			// Perform gemm subproblem.
			bli_gemm_int( &BLIS_ONE,
			              &a1_pack,
			              &b_pack_inc,
			              &BLIS_ONE,
			              &c1_pack_inc,
			              cntl_sub_gemm( cntl ) );
		}

		// Unpack C1 (if C1 was packed).
		bli_unpackm_int( &c1_pack, &c1, cntl_sub_unpackm_c( cntl ) );
	}


	// Partition along the remaining portion of the m dimension.
	for ( i = bm_alg; i < m_trans; i += bm_alg )
	{
		// Determine the current algorithmic blocksize.
		// NOTE: Use of a (for execution datatype) is intentional!
		// This causes the right blocksize to be used if c and a are
		// complex and b is real.
		bm_alg = bli_determine_blocksize_f( i, m_trans, a,
		                                    cntl_blocksize( cntl ) );

		// Acquire partitions for A1 and C1.
		bli_acquire_mpart_t2b( BLIS_SUBPART1,
		                       i, bm_alg, a, &a1 );
		bli_acquire_mpart_t2b( BLIS_SUBPART1,
		                       i, bm_alg, c, &c1 );

		// Initialize objects for packing A1 and C1.
		bli_packm_init( &a1, &a1_pack,
		                cntl_sub_packm_a( cntl ) );
		bli_packm_init( &c1, &c1_pack,
		                cntl_sub_packm_c( cntl ) );

		// Pack A1 (if instructed).
		bli_packm_int( &a1, &a1_pack,
		               cntl_sub_packm_a( cntl ) );

		// Pack C1 (if instructed).
		bli_packm_int( &c1, &c1_pack,
		               cntl_sub_packm_c( cntl ) );

		// Perform gemm subproblem.
		bli_gemm_int( &BLIS_ONE,
		              &a1_pack,
		              &b_pack,
		              &BLIS_ONE,
		              &c1_pack,
		              cntl_sub_gemm( cntl ) );

		// Unpack C1 (if C1 was packed).
		bli_unpackm_int( &c1_pack, &c1,
		                 cntl_sub_unpackm_c( cntl ) );
	}

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
	bli_obj_release_pack( &a1_pack );
	bli_obj_release_pack( &b_pack );
	bli_obj_release_pack( &c1_pack );
}
Esempio n. 14
0
void bli_trsm_blk_var2f( obj_t*  a,
                         obj_t*  b,
                         obj_t*  c,
                         trsm_t* cntl,
                         trsm_thrinfo_t* thread )
{
    obj_t a_pack_s;
    obj_t b1_pack_s, c1_pack_s;

    obj_t b1, c1;
	obj_t* a_pack = NULL;
	obj_t* b1_pack = NULL;
	obj_t* c1_pack = NULL;

	dim_t i;
	dim_t b_alg;
	dim_t n_trans;

	// Initialize pack objects for A that are passed into packm_init().
    if( thread_am_ochief( thread ) ) {
	    bli_obj_init_pack( &a_pack_s );

        // Initialize object for packing A.
        bli_packm_init( a, &a_pack_s,
                        cntl_sub_packm_a( cntl ) );

        // Scale C by beta (if instructed).
        bli_scalm_int( &BLIS_ONE,
                       c,
                       cntl_sub_scalm( cntl ) );
    }
    a_pack = thread_obroadcast( thread, &a_pack_s );

	// Initialize pack objects for B and C that are passed into packm_init().
    if( thread_am_ichief( thread ) ) {
        bli_obj_init_pack( &b1_pack_s );
        bli_obj_init_pack( &c1_pack_s );
    }
    b1_pack = thread_ibroadcast( thread, &b1_pack_s );
    c1_pack = thread_ibroadcast( thread, &c1_pack_s );

	// Pack A (if instructed).
	bli_packm_int( a, a_pack,
	               cntl_sub_packm_a( cntl ),
                   trmm_thread_sub_opackm( thread ) );

	// Query dimension in partitioning direction.
	n_trans = bli_obj_width_after_trans( *b );
    dim_t start, end;
    num_t datatype = bli_obj_execution_datatype( *a );
    bli_get_range( thread, 0, n_trans, 
                   bli_lcm( bli_info_get_default_nr( datatype ), bli_info_get_default_mr( datatype ) ),
                   &start, &end );

	// Partition along the n dimension.
	for ( i = start; i < end; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		b_alg = bli_determine_blocksize_f( i, end, b,
		                                   cntl_blocksize( cntl ) );

		// Acquire partitions for B1 and C1.
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, b, &b1 );
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, c, &c1 );

		// Initialize objects for packing A1 and B1.
        if( thread_am_ichief( thread ) ) {
            bli_packm_init( &b1, b1_pack,
                            cntl_sub_packm_b( cntl ) );
            bli_packm_init( &c1, c1_pack,
                            cntl_sub_packm_c( cntl ) );
        }
        thread_ibarrier( thread );

		// Pack B1 (if instructed).
		bli_packm_int( &b1, b1_pack,
		               cntl_sub_packm_b( cntl ),
                       trsm_thread_sub_ipackm( thread ) );

		// Pack C1 (if instructed).
		bli_packm_int( &c1, c1_pack,
		               cntl_sub_packm_c( cntl ),
                       trsm_thread_sub_ipackm( thread ) );

		// Perform trsm subproblem.
		bli_trsm_int( &BLIS_ONE,
		              a_pack,
		              b1_pack,
		              &BLIS_ONE,
		              c1_pack,
		              cntl_sub_trsm( cntl ),
                      trsm_thread_sub_trsm( thread ) );

		// Unpack C1 (if C1 was packed).
        bli_unpackm_int( c1_pack, &c1,
                         cntl_sub_unpackm_c( cntl ),
                         trsm_thread_sub_ipackm( thread ) );
	}

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
    thread_obarrier( thread );
    if( thread_am_ochief( thread ) )
    	bli_obj_release_pack( a_pack );
    if( thread_am_ichief( thread ) ) {
        bli_obj_release_pack( b1_pack );
        bli_obj_release_pack( c1_pack );
    }
}
Esempio n. 15
0
void bli_trmm_blk_var2f( obj_t*  a,
                         obj_t*  b,
                         obj_t*  c,
                         gemm_t* cntl,
                         trmm_thrinfo_t* thread )
{
    obj_t a_pack_s;
    obj_t b1_pack_s, c1_pack_s;
    
    obj_t b1, c1; 
    obj_t*  a_pack = NULL;
    obj_t*  b1_pack = NULL;
    obj_t*  c1_pack = NULL;

	dim_t i;
	dim_t b_alg;

	// Prune any zero region that exists along the partitioning dimension.
	bli_trmm_prune_unref_mparts_n( a, b, c );

    if( thread_am_ochief( thread ) ) { 
        // Initialize object for packing A
        bli_obj_init_pack( &a_pack_s );
        bli_packm_init( a, &a_pack_s,
                        cntl_sub_packm_a( cntl ) );

        // Scale C by beta (if instructed).
        bli_scalm_int( &BLIS_ONE,
                       c,  
                       cntl_sub_scalm( cntl ) );
    }   
    a_pack = thread_obroadcast( thread, &a_pack_s );

    // Initialize pack objects for B and C that are passed into packm_init().
    if( thread_am_ichief( thread ) ) { 
        bli_obj_init_pack( &b1_pack_s );
        bli_obj_init_pack( &c1_pack_s );
    }   
    b1_pack = thread_ibroadcast( thread, &b1_pack_s );
    c1_pack = thread_ibroadcast( thread, &c1_pack_s );

	// Pack A (if instructed).
	bli_packm_int( a, a_pack,
	               cntl_sub_packm_a( cntl ),
                   trmm_thread_sub_opackm( thread ) );

    dim_t my_start, my_end;
    bli_get_range_weighted_l2r( thread, b,
                                bli_blksz_get_mult_for_obj( b, cntl_blocksize( cntl ) ),
                                &my_start, &my_end );

	// Partition along the n dimension.
	for ( i = my_start; i < my_end; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		b_alg = bli_determine_blocksize_f( i, my_end, b,
		                                   cntl_blocksize( cntl ) );

		// Acquire partitions for B1 and C1.
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, b, &b1 );
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, c, &c1 );

		// Initialize objects for packing A1 and B1.
        if( thread_am_ichief( thread ) ) {
            bli_packm_init( &b1, b1_pack,
                            cntl_sub_packm_b( cntl ) );
            bli_packm_init( &c1, c1_pack,
                            cntl_sub_packm_c( cntl ) );
        }
        thread_ibarrier( thread );

		// Pack B1 (if instructed).
		bli_packm_int( &b1, b1_pack,
		               cntl_sub_packm_b( cntl ),
                       trmm_thread_sub_ipackm( thread ) );

		// Pack C1 (if instructed).
		bli_packm_int( &c1, c1_pack,
		               cntl_sub_packm_c( cntl ),
                       trmm_thread_sub_ipackm( thread ) );

		// Perform trmm subproblem.
		bli_trmm_int( &BLIS_ONE,
		              a_pack,
		              b1_pack,
		              &BLIS_ONE,
		              c1_pack,
		              cntl_sub_gemm( cntl ),
                      trmm_thread_sub_trmm( thread ) );
        thread_ibarrier( thread );

        // Unpack C1 (if C1 was packed).
        bli_unpackm_int( c1_pack, &c1,
                         cntl_sub_unpackm_c( cntl ),
                         trmm_thread_sub_ipackm( thread ) );
	}

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
    thread_obarrier( thread );
    if( thread_am_ochief( thread ) )
        bli_packm_release( a_pack, cntl_sub_packm_a( cntl ) );
    if( thread_am_ichief( thread ) ) {
        bli_packm_release( b1_pack, cntl_sub_packm_b( cntl ) );
        bli_packm_release( c1_pack, cntl_sub_packm_c( cntl ) );
    }
}
Esempio n. 16
0
void bli_herk_blk_var2f( obj_t*  a,
                         obj_t*  ah,
                         obj_t*  c,
                         gemm_t* cntl,
                         herk_thrinfo_t* thread )
{
    obj_t a_pack_s;
    obj_t ah1_pack_s, c1S_pack_s;

    obj_t ah1, c1, c1S;
    obj_t aS_pack;
    obj_t* a_pack;
    obj_t* ah1_pack;
    obj_t* c1S_pack;

	dim_t i;
	dim_t b_alg;
	dim_t n_trans;
	subpart_t stored_part;

	// The upper and lower variants are identical, except for which
	// merged subpartition is acquired in the loop body.
	if ( bli_obj_is_lower( *c ) ) stored_part = BLIS_SUBPART1B;
	else                          stored_part = BLIS_SUBPART1T;

    if( thread_am_ochief( thread ) ) {
        // Initialize object for packing A
	    bli_obj_init_pack( &a_pack_s );
        bli_packm_init( a, &a_pack_s,
                        cntl_sub_packm_a( cntl ) );

        // Scale C by beta (if instructed).
        bli_scalm_int( &BLIS_ONE,
                       c,
                       cntl_sub_scalm( cntl ) );
    }
    a_pack = thread_obroadcast( thread, &a_pack_s );

	// Initialize pack objects for C and A' that are passed into packm_init().
    if( thread_am_ichief( thread ) ) {
        bli_obj_init_pack( &ah1_pack_s );
        bli_obj_init_pack( &c1S_pack_s );
    }
    ah1_pack = thread_ibroadcast( thread, &ah1_pack_s );
    c1S_pack = thread_ibroadcast( thread, &c1S_pack_s );

	// Pack A (if instructed).
	bli_packm_int( a, a_pack,
	               cntl_sub_packm_a( cntl ),
                   herk_thread_sub_opackm( thread ) );

	// Query dimension in partitioning direction.
	n_trans = bli_obj_width_after_trans( *c );
    dim_t start, end;

    // Needs to be replaced with a weighted range because triangle
    bli_get_range_weighted( thread, 0, n_trans, 
                            bli_blksz_get_mult_for_obj( a, cntl_blocksize( cntl ) ),
                            bli_obj_is_lower( *c ), &start, &end );

	// Partition along the n dimension.
	for ( i = start; i < end; i += b_alg )
	{
		// Determine the current algorithmic blocksize.
		b_alg = bli_determine_blocksize_f( i, end, a,
		                                   cntl_blocksize( cntl ) );

		// Acquire partitions for A1' and C1.
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, ah, &ah1 );
		bli_acquire_mpart_l2r( BLIS_SUBPART1,
		                       i, b_alg, c, &c1 );

		// Partition off the stored region of C1 and the corresponding region
		// of A_pack.
        bli_acquire_mpart_t2b( stored_part,
                               i, b_alg, &c1, &c1S );
        bli_acquire_mpart_t2b( stored_part,
                               i, b_alg, a_pack, &aS_pack );

		// Initialize objects for packing A1' and C1.
        if( thread_am_ichief( thread ) ) {
            bli_packm_init( &ah1, ah1_pack,
                            cntl_sub_packm_b( cntl ) );
            bli_packm_init( &c1S, c1S_pack,
                            cntl_sub_packm_c( cntl ) );
        }
        thread_ibarrier( thread ) ;

		// Pack A1' (if instructed).
		bli_packm_int( &ah1, ah1_pack,
		               cntl_sub_packm_b( cntl ),
                       herk_thread_sub_ipackm( thread ) );

		// Pack C1 (if instructed).
		bli_packm_int( &c1S, c1S_pack,
		               cntl_sub_packm_c( cntl ),
                       herk_thread_sub_ipackm( thread ) ) ;

		// Perform herk subproblem.
		bli_herk_int( &BLIS_ONE,
		              &aS_pack,
		              ah1_pack,
		              &BLIS_ONE,
		              c1S_pack,
		              cntl_sub_gemm( cntl ),
                      herk_thread_sub_herk( thread ) );

        thread_ibarrier( thread );

		// Unpack C1 (if C1 was packed).
        bli_unpackm_int( c1S_pack, &c1S,
                         cntl_sub_unpackm_c( cntl ),
                         herk_thread_sub_ipackm( thread ) );
	}

	// If any packing buffers were acquired within packm, release them back
	// to the memory manager.
    thread_obarrier( thread );
    if( thread_am_ochief( thread ) )
        bli_packm_release( a_pack, cntl_sub_packm_a( cntl ) );
    if( thread_am_ichief( thread ) ) {
        bli_packm_release( ah1_pack, cntl_sub_packm_b( cntl ) );
        bli_packm_release( c1S_pack, cntl_sub_packm_c( cntl ) );
    }
}