mirror of
https://github.com/amd/blis.git
synced 2026-05-24 10:24:34 +00:00
2f3174330f
Details:
- Implemented a sophisticated data structure and set of APIs that track
the small blocks of memory (around 80-100 bytes each) used when
creating nodes for control and thread trees (cntl_t and thrinfo_t) as
well as thread communicators (thrcomm_t). The purpose of the small
block allocator, or sba, is to allow the library to transition into a
runtime state in which it does not perform any calls to malloc() or
free() during normal execution of level-3 operations, regardless of
the threading environment (potentially multiple application threads
as well as multiple BLIS threads). The functionality relies on a new
data structure, apool_t, which is (roughly speaking) a pool of
arrays, where each array element is a pool of small blocks. The outer
pool, which is protected by a mutex, provides separate arrays for each
application thread while the arrays each handle multiple BLIS threads
for any given application thread. The design minimizes the potential
for lock contention, as only concurrent application threads would
need to fight for the apool_t lock, and only if they happen to begin
their level-3 operations at precisely the same time. Thanks to Kiran
Varaganti and AMD for requesting this feature.
- Added a configure option to disable the sba pools, which are enabled
by default; renamed the --[dis|en]able-packbuf-pools option to
--[dis|en]able-pba-pools; and rewrote the --help text associated with
this new option and consolidated it with the --help text for the
option associated with the sba (--[dis|en]able-sba-pools).
- Moved the membrk field from the cntx_t to the rntm_t. We now pass in
a rntm_t* to the bli_membrk_acquire() and _release() APIs, just as we
do for bli_sba_acquire() and _release().
- Replaced all calls to bli_malloc_intl() and bli_free_intl() that are
used for small blocks with calls to bli_sba_acquire(), which takes a
rntm (in addition to the bytes requested), and bli_sba_release().
These latter two functions reduce to the former two when the sba pools
are disabled at configure-time.
- Added rntm_t* arguments to various cntl_t and thrinfo_t functions, as
required by the new usage of bli_sba_acquire() and _release().
- Moved the freeing of "old" blocks (those allocated prior to a change
in the block_size) from bli_membrk_acquire_m() to the implementation
of the pool_t checkout function.
- Miscellaneous improvements to the pool_t API.
- Added a block_size field to the pblk_t.
- Harmonized the way that the trsm_ukr testsuite module performs packing
relative to that of gemmtrsm_ukr, in part to avoid the need to create
a packm control tree node, which now requires a rntm_t that has been
initialized with an sba and membrk.
- Re-enable explicit call bli_finalize() in testsuite so that users who
run the testsuite with memory tracing enabled can check for memory
leaks.
- Manually imported the compact/minor changes from 61441b24 that cause
the rntm to be copied locally when it is passed in via one of the
expert APIs.
- Reordered parameters to various bli_thrcomm_*() functions so that the
thrcomm_t* to the comm being modified is last, not first.
- Added more descriptive tracing for allocating/freeing small blocks and
formalized via a new configure option: --[dis|en]able-mem-tracing.
- Moved some unused scalm code and headers into frame/1m/other.
- Whitespace changes to bli_pthread.c.
- Regenerated build/libblis-symbols.def.
245 lines
10 KiB
C
245 lines
10 KiB
C
/*
|
|
|
|
BLIS
|
|
An object-based framework for developing high-performance BLAS-like
|
|
libraries.
|
|
|
|
Copyright (C) 2014, The University of Texas at Austin
|
|
Copyright (C) 2018, Advanced Micro Devices, Inc.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are
|
|
met:
|
|
- Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
- Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
- Neither the name(s) of the copyright holder(s) nor the names of its
|
|
contributors may be used to endorse or promote products derived
|
|
from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
#include "blis.h"
|
|
|
|
void bli_error_init( void )
|
|
{
|
|
bli_error_init_msgs();
|
|
}
|
|
|
|
void bli_error_finalize( void )
|
|
{
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Internal array to hold error strings.
|
|
static char bli_error_string[BLIS_MAX_NUM_ERR_MSGS][BLIS_MAX_ERR_MSG_LENGTH];
|
|
|
|
void bli_error_init_msgs( void )
|
|
{
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_ERROR_CHECKING_LEVEL),
|
|
"Invalid error checking level." );
|
|
sprintf( bli_error_string_for_code(BLIS_UNDEFINED_ERROR_CODE),
|
|
"Undefined error code." );
|
|
sprintf( bli_error_string_for_code(BLIS_NULL_POINTER),
|
|
"Encountered unexpected null pointer." );
|
|
sprintf( bli_error_string_for_code(BLIS_NOT_YET_IMPLEMENTED),
|
|
"Requested functionality not yet implemented." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_SIDE),
|
|
"Invalid side parameter value." );
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_UPLO),
|
|
"Invalid uplo_t parameter value." );
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_TRANS),
|
|
"Invalid trans_t parameter value." );
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_CONJ),
|
|
"Invalid conj_t parameter value." );
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_DIAG),
|
|
"Invalid diag_t parameter value." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_NONUNIT_DIAG),
|
|
"Expected object with non-unit diagonal." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_DATATYPE),
|
|
"Invalid datatype value." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_FLOATING_POINT_DATATYPE),
|
|
"Expected floating-point datatype value." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_NONINTEGER_DATATYPE),
|
|
"Expected non-integer datatype value." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_NONCONSTANT_DATATYPE),
|
|
"Expected non-constant datatype value." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_REAL_DATATYPE),
|
|
"Expected real datatype value." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_INTEGER_DATATYPE),
|
|
"Expected integer datatype value." );
|
|
sprintf( bli_error_string_for_code(BLIS_INCONSISTENT_DATATYPES),
|
|
"Expected consistent datatypes (equal, or one being constant)." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_REAL_PROJ_OF),
|
|
"Expected second datatype to be real projection of first." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_REAL_VALUED_OBJECT),
|
|
"Expected real-valued object (ie: if complex, imaginary component equals zero)." );
|
|
sprintf( bli_error_string_for_code(BLIS_INCONSISTENT_PRECISIONS),
|
|
"Expected consistent precisions (both single or both double)." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_NONCONFORMAL_DIMENSIONS),
|
|
"Encountered non-conformal dimensions between objects." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_SCALAR_OBJECT),
|
|
"Expected scalar object." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_VECTOR_OBJECT),
|
|
"Expected vector object." );
|
|
sprintf( bli_error_string_for_code(BLIS_UNEQUAL_VECTOR_LENGTHS),
|
|
"Encountered unequal vector lengths." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_SQUARE_OBJECT),
|
|
"Expected square object." );
|
|
sprintf( bli_error_string_for_code(BLIS_UNEXPECTED_OBJECT_LENGTH),
|
|
"Unexpected object length." );
|
|
sprintf( bli_error_string_for_code(BLIS_UNEXPECTED_OBJECT_WIDTH),
|
|
"Unexpected object width." );
|
|
sprintf( bli_error_string_for_code(BLIS_UNEXPECTED_VECTOR_DIM),
|
|
"Unexpected vector dimension." );
|
|
sprintf( bli_error_string_for_code(BLIS_UNEXPECTED_DIAG_OFFSET),
|
|
"Unexpected object diagonal offset." );
|
|
sprintf( bli_error_string_for_code(BLIS_NEGATIVE_DIMENSION),
|
|
"Encountered negative dimension." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_ROW_STRIDE),
|
|
"Encountered invalid row stride relative to n dimension." );
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_COL_STRIDE),
|
|
"Encountered invalid col stride relative to m dimension." );
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_DIM_STRIDE_COMBINATION),
|
|
"Encountered invalid stride/dimension combination." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_GENERAL_OBJECT),
|
|
"Expected general object." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_HERMITIAN_OBJECT),
|
|
"Expected Hermitian object." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_SYMMETRIC_OBJECT),
|
|
"Expected symmetric object." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_TRIANGULAR_OBJECT),
|
|
"Expected triangular object." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_UPPER_OR_LOWER_OBJECT),
|
|
"Expected upper or lower triangular object." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_3x1_SUBPART),
|
|
"Encountered invalid 3x1 (vertical) subpartition label." );
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_1x3_SUBPART),
|
|
"Encountered invalid 1x3 (horizontal) subpartition label." );
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_3x3_SUBPART),
|
|
"Encountered invalid 3x3 (diagonal) subpartition label." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_UNEXPECTED_NULL_CONTROL_TREE),
|
|
"Encountered unexpected null control tree node." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_PACK_SCHEMA_NOT_SUPPORTED_FOR_UNPACK),
|
|
"Pack schema not yet supported/implemented for use with unpacking." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_NONNULL_OBJECT_BUFFER),
|
|
"Encountered object with non-zero dimensions containing null buffer." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_MALLOC_RETURNED_NULL),
|
|
"malloc() returned NULL; heap memory is likely exhausted." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_PACKBUF),
|
|
"Invalid packbuf_t value." );
|
|
sprintf( bli_error_string_for_code(BLIS_EXHAUSTED_CONTIG_MEMORY_POOL),
|
|
"Attempted to allocate more memory from contiguous pool than is available." );
|
|
sprintf( bli_error_string_for_code(BLIS_INSUFFICIENT_STACK_BUF_SIZE),
|
|
"Configured maximum stack buffer size is insufficient for register blocksizes currently in use." );
|
|
sprintf( bli_error_string_for_code(BLIS_ALIGNMENT_NOT_POWER_OF_TWO),
|
|
"Encountered memory alignment value that is either zero or not a power of two." );
|
|
sprintf( bli_error_string_for_code(BLIS_ALIGNMENT_NOT_MULT_OF_PTR_SIZE),
|
|
"Encountered memory alignment value that is not a multiple of sizeof(void*)." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_EXPECTED_OBJECT_ALIAS),
|
|
"Expected object to be alias." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_INVALID_ARCH_ID),
|
|
"Invalid architecture id value." );
|
|
|
|
sprintf( bli_error_string_for_code(BLIS_MC_DEF_NONMULTIPLE_OF_MR),
|
|
"Default MC is non-multiple of MR for one or more datatypes." );
|
|
sprintf( bli_error_string_for_code(BLIS_MC_MAX_NONMULTIPLE_OF_MR),
|
|
"Maximum MC is non-multiple of MR for one or more datatypes." );
|
|
sprintf( bli_error_string_for_code(BLIS_NC_DEF_NONMULTIPLE_OF_NR),
|
|
"Default NC is non-multiple of NR for one or more datatypes." );
|
|
sprintf( bli_error_string_for_code(BLIS_NC_MAX_NONMULTIPLE_OF_NR),
|
|
"Maximum NC is non-multiple of NR for one or more datatypes." );
|
|
sprintf( bli_error_string_for_code(BLIS_KC_DEF_NONMULTIPLE_OF_KR),
|
|
"Default KC is non-multiple of KR for one or more datatypes." );
|
|
sprintf( bli_error_string_for_code(BLIS_KC_MAX_NONMULTIPLE_OF_KR),
|
|
"Maximum KC is non-multiple of KR for one or more datatypes." );
|
|
}
|
|
|
|
void bli_print_msg( char* str, char* file, guint_t line )
|
|
{
|
|
fprintf( stderr, "\n" );
|
|
fprintf( stderr, "libblis: %s (line %lu):\n", file, ( long unsigned int )line );
|
|
fprintf( stderr, "libblis: %s\n", str );
|
|
fflush( stderr );
|
|
}
|
|
|
|
void bli_abort( void )
|
|
{
|
|
fprintf( stderr, "libblis: Aborting.\n" );
|
|
//raise( SIGABRT );
|
|
abort();
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// A mutex to allow synchronous access to bli_err_chk_level.
|
|
static bli_pthread_mutex_t err_mutex = BLIS_PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
// Current error checking level.
|
|
static errlev_t bli_err_chk_level = BLIS_FULL_ERROR_CHECKING;
|
|
|
|
errlev_t bli_error_checking_level( void )
|
|
{
|
|
return bli_err_chk_level;
|
|
}
|
|
|
|
void bli_error_checking_level_set( errlev_t new_level )
|
|
{
|
|
err_t e_val;
|
|
|
|
e_val = bli_check_valid_error_level( new_level );
|
|
bli_check_error_code( e_val );
|
|
|
|
// Acquire the mutex protecting bli_err_chk_level.
|
|
bli_pthread_mutex_lock( &err_mutex );
|
|
|
|
// BEGIN CRITICAL SECTION
|
|
{
|
|
bli_err_chk_level = new_level;
|
|
}
|
|
// END CRITICAL SECTION
|
|
|
|
// Release the mutex protecting bli_err_chk_level.
|
|
bli_pthread_mutex_unlock( &err_mutex );
|
|
}
|
|
|
|
bool_t bli_error_checking_is_enabled( void )
|
|
{
|
|
return bli_error_checking_level() != BLIS_NO_ERROR_CHECKING;
|
|
}
|
|
|
|
char* bli_error_string_for_code( gint_t code )
|
|
{
|
|
return bli_error_string[-code];
|
|
}
|
|
|