amd/blis
1
0
Fork 0
mirror of https://github.com/amd/blis.git synced 2026-05-11 17:50:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Redesigned control tree infrastructure.

Browse Source 
Details:
- Altered control tree node struct definitions so that all nodes have the
  same struct definition, whose primary fields consist of a blocksize id,
  a variant function pointer, a pointer to an optional parameter struct,
  and a pointer to a (single) sub-node. This unified control tree type is
  now named cntl_t.
- Changed the way control tree nodes are connected, and what computation
  they represent, such that, for example, packing operations are now
  associated with nodes that are "inline" in the tree, rather than off-
  shoot braches. The original tree for the classic Goto gemm algorithm was
  expressed (roughly) as:

    blk_var2 -> blk_var3 -> blk_var1 -> ker_var2
                         |           |
                         -> packb    -> packa

  and now, the same tree would look like:

    blk_var2 -> blk_var3 -> packb -> blk_var1 -> packa -> ker_var2

  Specifically, the packb and packa nodes perform their respective packing
  operations and then recurse (without any loop) to a subproblem. This means
  there are now two kinds of level-3 control tree nodes: partitioning and
  non-partitioning. The blocked variants are members of the former, because
  they iteratively partition off submatrices and perform suboperations on
  those partitions, while the packing variants belong to the latter group.
  (This change has the effect of allowing greatly simplified initialization
  of the nodes, which previously involved setting many unused node fields to
  NULL.)
- Changed the way thrinfo_t tree nodes are arranged to mirror the new
  connective structure of control trees. That is, packm nodes are no longer
  off-shoot branches of the main algorithmic nodes, but rather connected
  "inline".
- Simplified control tree creation functions. Partitioning nodes are created
  concisely with just a few fields needing initialization. By contrast, the
  packing nodes require additional parameters, which are stored in a
  packm-specific struct that is tracked via the optional parameters pointer
  within the control tree struct. (This parameter struct must always begin
  with a uint64_t that contains the byte size of the struct. This allows
  us to use a generic function to recursively copy control trees.) gemm,
  herk, and trmm control tree creation continues to be consolidated into
  a single function, with the operation family being used to select
  among the parameter-agnostic macro-kernel wrappers. A single routine,
  bli_cntl_free(), is provided to free control trees recursively, whereby
  the chief thread within a groups release the blocks associated with
  mem_t entries back to the memory broker from which they were acquired.
- Updated internal back-ends, e.g. bli_gemm_int(), to query and call the
  function pointer stored in the current control tree node (rather than
  index into a local function pointer array). Before being invoked, these
  function pointers are first cast to a gemm_voft (for gemm, herk, or trmm
  families) or trsm_voft (for trsm family) type, which is defined in
  frame/3/bli_l3_var_oft.h.
- Retired herk and trmm internal back-ends, since all execution now flows
  through gemm or trsm blocked variants.
- Merged forwards- and backwards-moving variants by querying the direction
  from routines as a function of the variant's matrix operands. gemm and
  herk always move forward, while trmm and trsm move in a direction that
  is dependent on which operand (a or b) is triangular.
- Added functions bli_thread_get_range_mdim(), bli_thread_get_range_ndim(),
  each of which takes additional arguments and hides complexity in managing
  the difference between the way ranges are computed for the four families
  of operations.
- Simplified level-3 blocked variants according to the above changes, so that
  the only steps taken are:
  1. Query partitioning direction (forwards or backwards).
  2. Prune unreferenced regions, if they exist.
  3. Determine the thread partitioning sub-ranges.
  <begin loop>
    4. Determine the partitioning blocksize (passing in the partitioning
       direction)
    5. Acquire the curren iteration's partitions for the matrices affected
       by the current variants's partitioning dimension (m, k, n).
    6. Call the subproblem.
  <end loop>
- Instantiate control trees once per thread, per operation invocation.
  (This is a change from the previous regime in which control trees were
  treated as stateless objects, initialized with the library, and shared
  as read-only objects between threads.) This once-per-thread allocation
  is done primarily to allow threads to use the control tree as as place
  to cache certain data for use in subsequent loop iterations. Presently,
  the only application of this caching is a mem_t entry for the packing
  blocks checked out from the memory broker (allocator). If a non-NULL
  control tree is passed in by the (expert) user, then the tree is copied
  by each thread. This is done in bli_l3_thread_decorator(), in
  bli_thrcomm_*.c.
- Added a new field to the context, and opid_t which tracks the "family"
  of the operation being executed. For example, gemm, hemm, and symm are
  all part of the gemm family, while herk, syrk, her2k, and syr2k are
  all part of the herk family. Knowing the operation's family is necessary
  when conditionally executing the internal (beta) scalar reset on on
  C in blocked variant 3, which is needed for gemm and herk families,
  but must not be performed for the trmm family (because beta has only
  been applied to the current row-panel of C after the first rank-kc
  iteration).
- Reexpressed 3m3 induced method blocked variant in frame/3/gemm/ind
  to comform with the new control tree design, and renamed the macro-
  kernel codes corresponding to 3m2 and 4m1b.
- Renamed bli_mem.c (and its APIs) to bli_memsys.c, and renamed/relocated
  bli_mem_macro_defs.h from frame/include to frame/base/bli_mem.h.
- Renamed/relocated bli_auxinfo_macro_defs.h from frame/include to
  frame/base/bli_auxinfo.h.
- Fixed a minor bug whereby the storage-to-ukr-preference matching
  optimization in the various level-3 front-ends was not being applied
  properly when the context indicated that execution would be via an
  induced method. (Before, we always checked the native micro-kernel
  corresponding to the datatype being executed, whereas now we check
  the native micro-kernel corresponding to the datatype's real projection,
  since that is the micro-kernel that is actually used by induced methods.
- Added an option to the testsuite to skip the testing of native level-3
  complex implementations. Previously, it was always tested, provided that
  the c/z datatypes were enabled. However, some configurations use
  reference micro-kernels for complex datatypes, and testing these
  implementations can slow down the testsuite considerably.
This commit is contained in:
Field G. Van Zee
2016-08-26 19:04:45 -05:00
parent 73517f522b
commit 701b9aa3ff
282 changed files with 5386 additions and 4842 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
frame/include/bli_extern_defs.h
View File

@@ -46,6 +46,5 @@ extern obj_t BLIS_MINUS_TWO;
extern thrcomm_t BLIS_SINGLE_COMM;
extern thrinfo_t BLIS_PACKM_SINGLE_THREADED;
extern thrinfo_t BLIS_GEMM_SINGLE_THREADED;
extern thrinfo_t BLIS_HERK_SINGLE_THREADED;
#endif

2
frame/include/bli_macro_defs.h
View File

@@ -120,14 +120,12 @@
#include "bli_gentfunc_macro_defs.h"
#include "bli_gentprot_macro_defs.h"
#include "bli_mem_macro_defs.h"
#include "bli_obj_macro_defs.h"
#include "bli_param_macro_defs.h"
#include "bli_complex_macro_defs.h"
#include "bli_scalar_macro_defs.h"
#include "bli_error_macro_defs.h"
#include "bli_blas_macro_defs.h"
#include "bli_auxinfo_macro_defs.h"
#endif

126
frame/include/bli_mem_macro_defs.h
View File

@@ -1,126 +0,0 @@
/*
BLIS
An object-based framework for developing high-performance BLAS-like
libraries.
Copyright (C) 2014, The University of Texas at Austin
Copyright (C) 2016 Hewlett Packard Enterprise Development LP
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 of The University of Texas at Austin 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.
*/
#ifndef BLIS_MEM_MACRO_DEFS_H
#define BLIS_MEM_MACRO_DEFS_H
// Mem entry query
#define bli_mem_pblk( mem_p ) \
\
( &((mem_p)->pblk) )
#define bli_mem_buffer( mem_p ) \
\
( bli_pblk_buf_align( bli_mem_pblk( mem_p ) ) )
#define bli_mem_buf_sys( mem_p ) \
\
( bli_pblk_buf_sys( bli_mem_pblk( mem_p ) ) )
#define bli_mem_buf_type( mem_p ) \
\
( (mem_p)->buf_type )
#define bli_mem_pool( mem_p ) \
\
( (mem_p)->pool )
#define bli_mem_membrk( mem_p ) \
\
( (mem_p)->membrk )
#define bli_mem_size( mem_p ) \
\
( (mem_p)->size )
#define bli_mem_is_alloc( mem_p ) \
\
( bli_mem_buffer( mem_p ) != NULL )
#define bli_mem_is_unalloc( mem_p ) \
\
( bli_mem_buffer( mem_p ) == NULL )
// Mem entry modification
#define bli_mem_set_pblk( pblk_p, mem_p ) \
{ \
mem_p->pblk = *(pblk_p); \
}
#define bli_mem_set_buffer( buf0, mem_p ) \
{ \
bli_pblk_set_buf_align( buf0, &(mem_p->pblk) ); \
}
#define bli_mem_set_buf_sys( buf0, mem_p ) \
{ \
bli_pblk_set_buf_sys( buf0, &(mem_p->pblk) ); \
}
#define bli_mem_set_buf_type( buf_type0, mem_p ) \
{ \
(mem_p)->buf_type = buf_type0; \
}
#define bli_mem_set_pool( pool0, mem_p ) \
{ \
(mem_p)->pool = pool0; \
}
#define bli_mem_set_membrk( membrk0, mem_p ) \
{ \
(mem_p)->membrk = membrk0; \
}
#define bli_mem_set_size( size0, mem_p ) \
{ \
mem_p->size = size0; \
}
#define bli_mem_clear( mem_p ) \
{ \
bli_mem_set_buffer( NULL, mem_p ); \
bli_mem_set_buf_sys( NULL, mem_p ); \
bli_mem_set_pool( NULL, mem_p ); \
bli_mem_set_size( 0, mem_p ); \
bli_mem_set_membrk( NULL, mem_p ); \
}
#endif

53
frame/include/bli_obj_macro_defs.h
View File

@@ -812,21 +812,6 @@ bli_obj_width_stored( obj )
(obj).elem_size = size; \
}
// Pack mem_t entry query
#define bli_obj_pack_mem( obj ) \
\
( &((obj).pack_mem) )
// Pack mem_t entry modification
#define bli_obj_set_pack_mem( mem_p, obj ) \
{ \
(obj).pack_mem = *mem_p; \
}
// Packed matrix info query
#define bli_obj_padded_length( obj ) \
@@ -839,6 +824,12 @@ bli_obj_width_stored( obj )
// Packed matrix info modification
#define bli_obj_set_buffer_to_mem( mem_p, obj ) \
{ \
void* buf = bli_mem_buffer( mem_p ); \
bli_obj_set_buffer( buf, obj ); \
} \
#define bli_obj_set_padded_length( m0, obj ) \
{ \
(obj).m_padded = m0; \
@@ -900,15 +891,7 @@ bli_obj_width_stored( obj )
// -- Miscellaneous object macros --
// Make a special alias (shallow copy) that does not overwrite pack_mem
// entry.
#define bli_obj_alias_for_packing( a, b ) \
{ \
bli_obj_init_basic_shallow_copy_of( a, b ); \
}
// Make a full alias (shallow copy), including pack_mem and friends
// Make a full alias (shallow copy)
#define bli_obj_alias_to( a, b ) \
{ \
@@ -948,28 +931,6 @@ bli_obj_width_stored( obj )
}
// Initialize object for packing purposes
#define bli_obj_init_pack( obj_p ) \
{ \
mem_t* pack_mem_ = bli_obj_pack_mem( *obj_p ); \
\
bli_mem_set_buffer( NULL, pack_mem_ ); \
}
// Release object's pack mem_t entries back to memory manager
#define bli_obj_release_pack( obj_p ) \
{ \
mem_t* pack_mem_ = bli_obj_pack_mem( *(obj_p) ); \
\
if ( bli_mem_is_alloc( pack_mem_ ) ) \
bli_membrk_release( pack_mem_ ); \
}
// Submatrix/scalar buffer acquisition
#define BLIS_CONSTANT_SLOT_SIZE BLIS_MAX_TYPE_SIZE

468
frame/include/bli_type_defs.h
View File

@@ -510,234 +510,6 @@ typedef enum
} dir_t;
//
// -- BLIS misc. structure types -----------------------------------------------
//
// -- Mutex type --
typedef struct mtx_s mtx_t;
// -- Pool block type --
typedef struct
{
void* buf_sys;
void* buf_align;
} pblk_t;
// -- Pool type --
typedef struct
{
pblk_t* block_ptrs;
dim_t block_ptrs_len;
dim_t top_index;
dim_t num_blocks;
siz_t block_size;
siz_t align_size;
} pool_t;
// -- Memory broker object type --
typedef struct membrk_s membrk_t;
/*
{
pool_t pools[3];
mtx_t mutex;
malloc_ft malloc_fp;
free_ft free_fp;
} membrk_t;
*/
// -- Memory object type --
typedef struct mem_s
{
pblk_t pblk;
packbuf_t buf_type;
pool_t* pool;
membrk_t* membrk;
siz_t size;
} mem_t;
// -- Blocksize object type --
typedef struct blksz_s
{
// Primary blocksize values.
dim_t v[BLIS_NUM_FP_TYPES];
// Blocksize extensions.
dim_t e[BLIS_NUM_FP_TYPES];
} blksz_t;
// -- Function pointer object type --
typedef struct func_s
{
// Kernel function address.
void* ptr[BLIS_NUM_FP_TYPES];
} func_t;
// -- Multi-boolean object type --
typedef struct mbool_s
{
bool_t v[BLIS_NUM_FP_TYPES];
} mbool_t;
// -- Auxiliary kernel info type --
// Note: This struct is used by macro-kernels to package together extra
// parameter values that may be of use to the micro-kernel without
// cluttering up the micro-kernel interface itself.
typedef struct
{
// The pack schemas of A and B.
pack_t schema_a;
pack_t schema_b;
// Pointers to the micro-panels of A and B which will be used by the
// next call to the micro-kernel.
void* a_next;
void* b_next;
// The imaginary strides of A and B.
inc_t is_a;
inc_t is_b;
} auxinfo_t;
//
// -- BLIS object type definitions ---------------------------------------------
//
typedef struct obj_s
{
// Basic fields
struct obj_s* root;
dim_t off[2];
dim_t dim[2];
doff_t diag_off;
objbits_t info;
siz_t elem_size;
void* buffer;
inc_t rs;
inc_t cs;
inc_t is;
// Bufferless scalar storage
atom_t scalar;
// Pack-related fields
mem_t pack_mem; // cached memory region for packing
dim_t m_padded; // m dimension of matrix, including any padding
dim_t n_padded; // n dimension of matrix, including any padding
inc_t ps; // panel stride (distance to next panel)
inc_t pd; // panel dimension (the "width" of a panel:
// usually MR or NR)
dim_t m_panel; // m dimension of a "full" panel
dim_t n_panel; // n dimension of a "full" panel
} obj_t;
// Define these macros here since they must be updated if contents of
// obj_t changes.
#define bli_obj_init_basic_shallow_copy_of( a, b ) \
{ \
(b).root = (a).root; \
\
(b).off[0] = (a).off[0]; \
(b).off[1] = (a).off[1]; \
(b).dim[0] = (a).dim[0]; \
(b).dim[1] = (a).dim[1]; \
(b).diag_off = (a).diag_off; \
\
(b).info = (a).info; \
(b).elem_size = (a).elem_size; \
\
(b).buffer = (a).buffer; \
(b).rs = (a).rs; \
(b).cs = (a).cs; \
(b).is = (a).is; \
\
(b).scalar = (a).scalar; \
\
/* We must NOT copy pack_mem field since this macro forms the basis of
bli_obj_alias_to(), which is used in packm_init(). There, we want to
copy the basic fields of the obj_t but PRESERVE the pack_mem field
of the destination object since it holds the "cached" mem_t object
and buffer. The other fields, such as padded dimensions, are always
set by bli_packm_init(), so we don't need to copy them either. */ \
}
#define bli_obj_init_full_shallow_copy_of( a, b ) \
{ \
/* This macro implements a full alias (shallow copy) that copies all
fields of the obj_t struct. */ \
bli_obj_init_basic_shallow_copy_of( a, b ); \
\
(b).pack_mem = (a).pack_mem; \
(b).m_padded = (a).m_padded; \
(b).n_padded = (a).n_padded; \
(b).ps = (a).ps; \
(b).pd = (a).pd; \
(b).m_panel = (a).m_panel; \
(b).n_panel = (a).n_panel; \
}
#define bli_obj_init_subpart_from( a, b ) \
{ \
(b).root = (a).root; \
\
(b).off[0] = (a).off[0]; \
(b).off[1] = (a).off[1]; \
/* Avoid copying m since it will be overwritten. */ \
/* Avoid copying n since it will be overwritten. */ \
(b).diag_off = (a).diag_off; \
\
(b).info = (a).info; \
(b).elem_size = (a).elem_size; \
\
(b).buffer = (a).buffer; \
(b).rs = (a).rs; \
(b).cs = (a).cs; \
(b).is = (a).is; \
\
(b).scalar = (a).scalar; \
\
/* We want to copy the pack_mem field here because this macro is used
when creating subpartitions, including those of packed objects. In
those situations, we want the subpartition to inherit the pack_mem
field of its parent, as well as other related fields such as the
padded dimensions. */ \
(b).pack_mem = (a).pack_mem; \
(b).m_padded = (a).m_padded; \
(b).n_padded = (a).n_padded; \
(b).pd = (a).pd; \
(b).ps = (a).ps; \
(b).m_panel = (a).m_panel; \
(b).n_panel = (a).n_panel; \
}
//
// -- Other BLIS enumerated type definitions -----------------------------------
//
// -- Subpartition type --
typedef enum
@@ -791,6 +563,7 @@ typedef enum
#define BLIS_MACH_PARAM_FIRST BLIS_MACH_EPS
#define BLIS_MACH_PARAM_LAST BLIS_MACH_EPS2
// -- Induced method types --
typedef enum
@@ -807,6 +580,7 @@ typedef enum
#define BLIS_NUM_IND_METHODS (BLIS_NAT+1)
// -- Kernel ID types --
typedef enum
@@ -828,6 +602,7 @@ typedef enum
#define BLIS_NUM_LEVEL1V_KERS 13
typedef enum
{
BLIS_AXPY2V_KER = 0,
@@ -839,6 +614,7 @@ typedef enum
#define BLIS_NUM_LEVEL1F_KERS 5
typedef enum
{
BLIS_GEMM_UKR = 0,
@@ -850,6 +626,7 @@ typedef enum
#define BLIS_NUM_LEVEL3_UKRS 5
typedef enum
{
BLIS_REFERENCE_UKERNEL = 0,
@@ -911,11 +688,245 @@ typedef enum
BLIS_DF, // level-1f dotxf fusing factor
BLIS_XF, // level-1f dotxaxpyf fusing factor
BLIS_VF, // level-1v vector fusing factor
BLIS_NO_PART, // used as a placeholder when blocksizes are not applicable.
} bszid_t;
#define BLIS_NUM_BLKSZS 13
//
// -- BLIS misc. structure types -----------------------------------------------
//
// -- Mutex type --
typedef struct mtx_s mtx_t;
// -- Pool block type --
typedef struct
{
void* buf_sys;
void* buf_align;
} pblk_t;
// -- Pool type --
typedef struct
{
pblk_t* block_ptrs;
dim_t block_ptrs_len;
dim_t top_index;
dim_t num_blocks;
siz_t block_size;
siz_t align_size;
} pool_t;
// -- Memory broker object type --
typedef struct membrk_s membrk_t;
/*
{
pool_t pools[3];
mtx_t mutex;
malloc_ft malloc_fp;
free_ft free_fp;
} membrk_t;
*/
// -- Memory object type --
typedef struct mem_s
{
pblk_t pblk;
packbuf_t buf_type;
pool_t* pool;
membrk_t* membrk;
siz_t size;
} mem_t;
// -- Control tree node type --
struct cntl_s
{
// Basic fields (usually required).
bszid_t bszid;
void* var_func;
struct cntl_s* sub_node;
// Optional fields (needed only by some operations such as packm).
// NOTE: first field of params must be a uint64_t containing the size
// of the struct.
void* params;
// Internal fields that track "cached" data.
mem_t pack_mem;
};
typedef struct cntl_s cntl_t;
// -- Blocksize object type --
typedef struct blksz_s
{
// Primary blocksize values.
dim_t v[BLIS_NUM_FP_TYPES];
// Blocksize extensions.
dim_t e[BLIS_NUM_FP_TYPES];
} blksz_t;
// -- Function pointer object type --
typedef struct func_s
{
// Kernel function address.
void* ptr[BLIS_NUM_FP_TYPES];
} func_t;
// -- Multi-boolean object type --
typedef struct mbool_s
{
bool_t v[BLIS_NUM_FP_TYPES];
} mbool_t;
// -- Auxiliary kernel info type --
// Note: This struct is used by macro-kernels to package together extra
// parameter values that may be of use to the micro-kernel without
// cluttering up the micro-kernel interface itself.
typedef struct
{
// The pack schemas of A and B.
pack_t schema_a;
pack_t schema_b;
// Pointers to the micro-panels of A and B which will be used by the
// next call to the micro-kernel.
void* a_next;
void* b_next;
// The imaginary strides of A and B.
inc_t is_a;
inc_t is_b;
} auxinfo_t;
//
// -- BLIS object type definitions ---------------------------------------------
//
typedef struct obj_s
{
// Basic fields
struct obj_s* root;
dim_t off[2];
dim_t dim[2];
doff_t diag_off;
objbits_t info;
siz_t elem_size;
void* buffer;
inc_t rs;
inc_t cs;
inc_t is;
// Bufferless scalar storage
atom_t scalar;
// Pack-related fields
dim_t m_padded; // m dimension of matrix, including any padding
dim_t n_padded; // n dimension of matrix, including any padding
inc_t ps; // panel stride (distance to next panel)
inc_t pd; // panel dimension (the "width" of a panel:
// usually MR or NR)
dim_t m_panel; // m dimension of a "full" panel
dim_t n_panel; // n dimension of a "full" panel
} obj_t;
// Define these macros here since they must be updated if contents of
// obj_t changes.
#define bli_obj_init_full_shallow_copy_of( a, b ) \
{ \
(b).root = (a).root; \
\
(b).off[0] = (a).off[0]; \
(b).off[1] = (a).off[1]; \
(b).dim[0] = (a).dim[0]; \
(b).dim[1] = (a).dim[1]; \
(b).diag_off = (a).diag_off; \
\
(b).info = (a).info; \
(b).elem_size = (a).elem_size; \
\
(b).buffer = (a).buffer; \
(b).rs = (a).rs; \
(b).cs = (a).cs; \
(b).is = (a).is; \
\
(b).scalar = (a).scalar; \
\
/*(b).pack_mem = (a).pack_mem;*/ \
(b).m_padded = (a).m_padded; \
(b).n_padded = (a).n_padded; \
(b).ps = (a).ps; \
(b).pd = (a).pd; \
(b).m_panel = (a).m_panel; \
(b).n_panel = (a).n_panel; \
}
#define bli_obj_init_subpart_from( a, b ) \
{ \
(b).root = (a).root; \
\
(b).off[0] = (a).off[0]; \
(b).off[1] = (a).off[1]; \
/* Avoid copying m since it will be overwritten. */ \
/* Avoid copying n since it will be overwritten. */ \
(b).diag_off = (a).diag_off; \
\
(b).info = (a).info; \
(b).elem_size = (a).elem_size; \
\
(b).buffer = (a).buffer; \
(b).rs = (a).rs; \
(b).cs = (a).cs; \
(b).is = (a).is; \
\
(b).scalar = (a).scalar; \
\
/* We want to copy the pack_mem field here because this macro is used
when creating subpartitions, including those of packed objects. In
those situations, we want the subpartition to inherit the pack_mem
field of its parent, as well as other related fields such as the
padded dimensions. */ \
/*(b).pack_mem = (a).pack_mem;*/ \
(b).m_padded = (a).m_padded; \
(b).n_padded = (a).n_padded; \
(b).pd = (a).pd; \
(b).ps = (a).ps; \
(b).m_panel = (a).m_panel; \
(b).n_panel = (a).n_panel; \
}
// -- Context type --
typedef struct cntx_s
@@ -932,6 +943,7 @@ typedef struct cntx_s
func_t packm_ukrs;
opid_t family;
ind_t method;
pack_t schema_a;
pack_t schema_b;

2
frame/include/blis.h
View File

@@ -106,6 +106,7 @@ extern "C" {
#include "bli_ind.h"
#include "bli_membrk.h"
#include "bli_pool.h"
#include "bli_memsys.h"
#include "bli_mem.h"
#include "bli_part.h"
#include "bli_prune.h"
@@ -113,6 +114,7 @@ extern "C" {
#include "bli_blksz.h"
#include "bli_func.h"
#include "bli_mbool.h"
#include "bli_auxinfo.h"
#include "bli_param_map.h"
#include "bli_clock.h"
#include "bli_check.h"