Skip to content

Commit

Permalink
sparsity: removed unused code
Browse files Browse the repository at this point in the history 
sparsity: allocate additional memory for tile offsets

sparsity: decomp_buf via scratchpad
  • Loading branch information
@antonvor
antonvor committed Jan 5, 2023
1 parent 26ad002 commit 0134954
Show file tree
Hide file tree
Showing 19 changed files with 57 additions and 576 deletions.
52 changes: 1 addition & 51 deletions include/oneapi/dnnl/dnnl.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1169,11 +1169,7 @@ dnnl_status_t DNNL_API dnnl_memory_desc_init_by_tag(
/// @returns #dnnl_success on success and a status describing the error
/// otherwise.
dnnl_status_t DNNL_API dnnl_sparse_desc_init(dnnl_sparse_desc_t *sparse_desc,
dnnl_sparse_encoding_t encoding, int ndims_order,
const dnnl_dims_t dims_order, dnnl_dim_t nnze, int ntypes,
const dnnl_data_type_t *metadata_types, int nentry_dims,
const dnnl_dim_t *entry_dims, int structure_ndims,
const dnnl_dim_t *structure_dims, const dnnl_dim_t *structure_nnz);
dnnl_sparse_encoding_t encoding);

/// Initializes a memory descriptor by the given sparse descriptor.
///
Expand Down Expand Up @@ -1316,17 +1312,6 @@ int DNNL_API dnnl_memory_desc_equal(
size_t DNNL_API dnnl_memory_desc_get_size(
const dnnl_memory_desc_t *memory_desc);

/// Returns the size of a values and metadata for a particular sparse encoding.
///
/// @param memory_desc Memory descriptor.
/// @param index Index that correspondes to values or metadata. Each sparse
/// encoding defines index interpretation.
///
/// @returns The number of bytes required for values or metadata for a
/// particular sparse encoding described by a memory descriptor.
size_t DNNL_API dnnl_memory_desc_get_size_sparse(
const dnnl_memory_desc_t *memory_desc, int index);

/// Returns the size of data type.
///
/// @param data_type Data type.
Expand Down Expand Up @@ -1357,27 +1342,6 @@ dnnl_status_t DNNL_API dnnl_memory_create(dnnl_memory_t *memory,
const dnnl_memory_desc_t *memory_desc, dnnl_engine_t engine,
void *handle);

/// Creates a sparse memory object.
///
/// @param memory Output memory object.
/// @param memory_desc Memory descriptor.
/// @param engine Engine to use.
/// @param nhandles Number of handles.
/// @param handles Handles of the memory buffers to use as underlying storages.
/// For each element of the @p handles array the following applies:
/// - A pointer to the user-allocated buffer. In this case the library
/// doesn't own the buffer.
/// - The DNNL_MEMORY_ALLOCATE special value. Instructs the library to
/// allocate the buffer for the memory object. In this case the library
/// owns the buffer.
/// - DNNL_MEMORY_NONE Instructs the library to skip allocation of the
/// memory buffer.
/// @returns #dnnl_success on success and a status describing the error
/// otherwise.
dnnl_status_t DNNL_API dnnl_memory_create_sparse(dnnl_memory_t *memory,
const dnnl_memory_desc_t *memory_desc, dnnl_engine_t engine,
dnnl_dim_t nhandles, void **handles);

/// Returns the memory descriptor for a memory object.
///
/// @param memory Memory object.
Expand Down Expand Up @@ -1439,13 +1403,6 @@ dnnl_status_t DNNL_API dnnl_memory_map_data(
dnnl_status_t DNNL_API dnnl_memory_unmap_data(
const_dnnl_memory_t memory, void *mapped_ptr);

// TODO: add documentation and put these in the right place.
dnnl_status_t DNNL_API dnnl_memory_map_data_sparse(
const_dnnl_memory_t memory, int index, void **mapped_ptr);

dnnl_status_t DNNL_API dnnl_memory_unmap_data_sparse(
const_dnnl_memory_t memory, int index, void *mapped_ptr);

/// Returns memory object's data handle.
///
/// @param memory Memory object.
Expand All @@ -1470,13 +1427,6 @@ dnnl_status_t DNNL_API dnnl_memory_set_data_handle(

dnnl_status_t DNNL_API dnnl_memory_set_data_handle_no_pads_proc(
dnnl_memory_t memory, void *handle);

// TODO: add documentation and put these in the right place.
dnnl_status_t DNNL_API dnnl_memory_get_data_handles(
const_dnnl_memory_t memory, dnnl_dim_t *nhandles, void **handles);

dnnl_status_t DNNL_API dnnl_memory_set_data_handles(
dnnl_memory_t memory, dnnl_dim_t nhandles, void **handles);

/// Sets the underlying memory buffer.
///
Expand Down
143 changes: 7 additions & 136 deletions include/oneapi/dnnl/dnnl.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2497,22 +2497,9 @@ struct memory : public handle<dnnl_memory_t> {
/// A memory descriptor.
struct desc {
struct sparse_desc {
sparse_desc(dnnl_sparse_encoding_t encoding, const dims &dims_order,
dim nnze, const std::vector<data_type> &metadata_types,
const dims &entry_dims, const dims &structure_dims,
const dims &structure_nnz, bool allow_empty = false) {
std::vector<dnnl_data_type_t> c_metadata_types(
metadata_types.size());
for (size_t i = 0; i < c_metadata_types.size(); i++) {
c_metadata_types[i] = convert_to_c(metadata_types[i]);
}
sparse_desc(dnnl_sparse_encoding_t encoding, bool allow_empty = false) {
// TODO: check structure_dims.size() == structure_nnz.size();
dnnl_status_t status = dnnl_sparse_desc_init(&data, encoding,
(int)dims_order.size(), dims_order.data(), nnze,
(int)c_metadata_types.size(), c_metadata_types.data(),
(int)entry_dims.size(), entry_dims.data(),
(int)structure_dims.size(), structure_dims.data(),
structure_nnz.data());
dnnl_status_t status = dnnl_sparse_desc_init(&data, encoding);
if (!allow_empty)
error::wrap_c_api(
status, "could not construct a sparse descriptor");
Expand Down Expand Up @@ -2602,41 +2589,8 @@ struct memory : public handle<dnnl_memory_t> {
"sparse descriptor");
}

/// Function for creating CSR sparse desc with unstructured sparsity.
static sparse_desc csr(dim nnze, data_type index_type,
data_type pointer_type, bool allow_empty = false) {
return sparse_desc(dnnl_sparse_encoding_csr, {0, 1}, nnze,
{index_type, pointer_type}, {}, {}, {}, allow_empty);
}

/// Function for creating CSC sparse desc with unstructured sparsity.
static sparse_desc csc(dim nnze, data_type index_type,
data_type pointer_type, bool allow_empty = false) {
return sparse_desc(dnnl_sparse_encoding_csc, {1, 0}, nnze,
{index_type, pointer_type}, {}, {}, {}, allow_empty);
}

/// Function for creating BCSR sparse desc with unstructured sparsity.
static sparse_desc bcsr(dim nnze, data_type index_type,
data_type pointer_type, const dims &block_dims,
bool allow_empty = false) {
return sparse_desc(dnnl_sparse_encoding_bcsr, {0, 1}, nnze,
{index_type, pointer_type}, block_dims, {}, {},
allow_empty);
}

/// Function for creating BCSC sparse desc unstructured sparsity.
static sparse_desc bcsc(dim nnze, data_type index_type,
data_type pointer_type, const dims &block_dims,
bool allow_empty = false) {
return sparse_desc(dnnl_sparse_encoding_bcsc, {1, 0}, nnze,
{index_type, pointer_type}, block_dims, {}, {},
allow_empty);
}

static sparse_desc packed(dim nnze, bool allow_empty = false) {
return sparse_desc(dnnl_sparse_encoding_packed, {}, nnze, {}, {},
{}, {}, allow_empty);
static sparse_desc packed(bool allow_empty = false) {
return sparse_desc(dnnl_sparse_encoding_packed, allow_empty);
}

/// Constructs a memory descriptor for a region inside an area
Expand Down Expand Up @@ -2786,18 +2740,6 @@ struct memory : public handle<dnnl_memory_t> {
/// including the padding area.
size_t get_size() const { return dnnl_memory_desc_get_size(&data); }

/// Returns the size of a values and metadata for a particular sparse
/// encoding.
///
/// @param index Index that correspondes to values or metadata.
/// Each sparse encoding defines index interpretation.
///
/// @returns The number of bytes required for values or metadata for a
/// particular sparse encoding described by a memory descriptor.
size_t get_size(int index) const {
return dnnl_memory_desc_get_size_sparse(&data, index);
}

/// Checks whether the memory descriptor is zero (empty).
/// @returns @c true if the memory descriptor describes an empty
/// memory and @c false otherwise.
Expand Down Expand Up @@ -2858,44 +2800,12 @@ struct memory : public handle<dnnl_memory_t> {

/// Constructs a memory object.
///
/// The underlying buffer(s) for the memory will be allocated by the
/// library.
/// The underlying buffer for the memory will be allocated by the library.
///
/// @param md Memory descriptor.
/// @param aengine Engine to store the data on.
memory(const desc &md, const engine &aengine) {
dnnl_status_t status;
dnnl_memory_t result;
const bool is_sparse_md = md.data.format_kind == dnnl_format_sparse;
if (is_sparse_md) {
// Deduce number of handles.
dim nhandles = 0;
switch (md.data.format_desc.sparse_desc.encoding) {
case dnnl_sparse_encoding_csr:
case dnnl_sparse_encoding_csc:
case dnnl_sparse_encoding_bcsr:
case dnnl_sparse_encoding_bcsc: nhandles = 3; break;
case dnnl_sparse_encoding_packed: nhandles = 1; break;
default: nhandles = 0;
}
std::vector<void *> handles(nhandles, DNNL_MEMORY_ALLOCATE);
status = dnnl_memory_create_sparse(&result, &md.data, aengine.get(),
(dim)handles.size(), handles.data());
} else {
status = dnnl_memory_create(
&result, &md.data, aengine.get(), DNNL_MEMORY_ALLOCATE);
}
error::wrap_c_api(status, "could not create a memory object");
reset(result);
}

memory(const desc &md, const engine &aengine, std::vector<void *> handles) {
dnnl_memory_t result;
dnnl_status_t status = dnnl_memory_create_sparse(&result, &md.data,
aengine.get(), (dim)handles.size(), handles.data());
error::wrap_c_api(status, "could not create a memory object");
reset(result);
}
memory(const desc &md, const engine &aengine)
: memory(md, aengine, DNNL_MEMORY_ALLOCATE) {}

/// Returns the associated memory descriptor.
desc get_desc() const {
Expand Down Expand Up @@ -2924,28 +2834,6 @@ struct memory : public handle<dnnl_memory_t> {
return handle;
}

// TODO: add documentation.
std::vector<void *> get_data_handles() const {
dim nhandles;
error::wrap_c_api(
dnnl_memory_get_data_handles(get(), &nhandles, nullptr),
"could not get a number of native handles from a memory "
"object");
std::vector<void *> handles(nhandles);
error::wrap_c_api(
dnnl_memory_get_data_handles(get(), &nhandles, handles.data()),
"could not get native handles from a memory object");
return handles;
}

// TODO: add documentation.
void set_data_handles(std::vector<void *> handles) {
dim nhandles = handles.size();
error::wrap_c_api(
dnnl_memory_set_data_handles(get(), nhandles, handles.data()),
"could not set native handles of a memory object");
}

/// Sets the underlying memory buffer.
///
/// This function may write zero values to the memory specified by the @p
Expand Down Expand Up @@ -3031,23 +2919,6 @@ struct memory : public handle<dnnl_memory_t> {
return static_cast<T *>(mapped_ptr);
}

// TODO: add documentation.
template <typename T = void>
T *map_data(int index) const {
void *mapped_ptr;
error::wrap_c_api(
dnnl_memory_map_data_sparse(get(), index, &mapped_ptr),
"could not map memory object data");
return static_cast<T *>(mapped_ptr);
}

// TODO: add documentation.
void unmap_data(int index, void *mapped_ptr) const {
error::wrap_c_api(
dnnl_memory_unmap_data_sparse(get(), index, mapped_ptr),
"could not unmap memory object data");
}

/// Unmaps a memory object and writes back any changes made to the
/// previously mapped memory buffer.
///
Expand Down
26 changes: 0 additions & 26 deletions include/oneapi/dnnl/dnnl_types.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1823,38 +1823,12 @@ typedef struct {
typedef enum {
dnnl_sparse_encoding_undef = 0,
dnnl_sparse_encoding_any,
dnnl_sparse_encoding_csr,
dnnl_sparse_encoding_csc,
dnnl_sparse_encoding_bcsr,
dnnl_sparse_encoding_bcsc,
dnnl_sparse_encoding_packed,
} dnnl_sparse_encoding_t;

/// Maximum number of types for metadata.
#define DNNL_MAX_METADATA_TYPES 12

typedef struct {
/// Specifies what encoding is used.
dnnl_sparse_encoding_t encoding;
/// Order of dimensions. E.g. for CSR it's [0, 1], for CSC [1, 0].
dnnl_dims_t dims_order;
/// Number of non-zero entries.
dnnl_dim_t nnze;
/// Metadata types. Each encoding defines how to interpret these.
dnnl_data_type_t metadata_types[DNNL_MAX_METADATA_TYPES];
/// Dimensions of an entry. For example: 1x1 for CSR/CSC or MxN for
/// BCSR/BCSC.
dnnl_dim_t entry_dims[2];

/// Section that describes sparsity pattern.
///
/// Number of dimensions of a structure block. When ndims is 0 then sparsity
/// pattern is considered unstructured.
int structure_ndims;
/// Dimensions of a structure block.
dnnl_dim_t structure_dims[2];
/// Number of non-zero elements per-dimension.
dnnl_dim_t structure_nnz[2];
/// Descriptor for blocked bitmask - opaque.
dnnl_blocking_desc_t packed_desc;
} dnnl_sparse_desc_t;
Expand Down
4 changes: 0 additions & 4 deletions src/common/c_types_map.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1221,10 +1221,6 @@ using sparse_encoding_t = dnnl_sparse_encoding_t;
namespace sparse_encoding {
const sparse_encoding_t undef = dnnl_sparse_encoding_undef;
const sparse_encoding_t any = dnnl_sparse_encoding_any;
const sparse_encoding_t csr = dnnl_sparse_encoding_csr;
const sparse_encoding_t csc = dnnl_sparse_encoding_csc;
const sparse_encoding_t bcsr = dnnl_sparse_encoding_bcsr;
const sparse_encoding_t bcsc = dnnl_sparse_encoding_bcsc;
const sparse_encoding_t packed = dnnl_sparse_encoding_packed;
} // namespace sparse_encoding

Expand Down
4 changes: 0 additions & 4 deletions src/common/dnnl_debug_autogenerated.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1212,10 +1212,6 @@ const char *dnnl_alg_kind2str(dnnl_alg_kind_t v) {
const char *dnnl_sparse_encoding2str(dnnl_sparse_encoding_t v) {
if (v == dnnl_sparse_encoding_undef) return "undef";
if (v == dnnl_sparse_encoding_any) return "any";
if (v == dnnl_sparse_encoding_csr) return "sparse_encoding_csr";
if (v == dnnl_sparse_encoding_csc) return "sparse_encoding_csc";
if (v == dnnl_sparse_encoding_bcsr) return "sparse_encoding_bcsr";
if (v == dnnl_sparse_encoding_bcsc) return "sparse_encoding_bcsc";
if (v == dnnl_sparse_encoding_packed) return "sparse_encoding_packed";
assert(!"unknown sparse_encoding");
return "unknown sparse_encoding";
Expand Down
Loading

0 comments on commit 0134954

Please sign in to comment.