areusch commented on code in PR #10189:
URL: https://github.com/apache/tvm/pull/10189#discussion_r899637782
##########
src/ir/memory_pools.cc:
##########
@@ -71,6 +60,151 @@ TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
<< ",\n target_burst_bytes=" << node->target_burst_bytes <<
")";
});
+PoolInfoProperties::PoolInfoProperties(Integer size_hint_bytes, Integer
clock_frequency_hz,
+ Integer read_bandwidth_bytes_per_cycle,
+ Integer write_bandwidth_bytes_per_cycle,
+ Integer read_latency_cycles, Integer
write_latency_cycles,
+ Map<Target, Integer>
target_burst_bytes, Bool is_internal) {
+ auto poolinfo_properties_node = make_object<PoolInfoPropertiesNode>();
+ poolinfo_properties_node->size_hint_bytes = size_hint_bytes;
+ poolinfo_properties_node->clock_frequency_hz = clock_frequency_hz;
+ poolinfo_properties_node->read_bandwidth_bytes_per_cycle =
read_bandwidth_bytes_per_cycle;
+ poolinfo_properties_node->write_bandwidth_bytes_per_cycle =
write_bandwidth_bytes_per_cycle;
+ poolinfo_properties_node->read_latency_cycles = read_latency_cycles;
+ poolinfo_properties_node->write_latency_cycles = write_latency_cycles;
+ poolinfo_properties_node->target_burst_bytes = target_burst_bytes;
+ poolinfo_properties_node->is_internal = is_internal;
+ data_ = std::move(poolinfo_properties_node);
+}
+
+TVM_REGISTER_NODE_TYPE(PoolInfoPropertiesNode);
+TVM_REGISTER_GLOBAL("ir.PoolInfoProperties")
+ .set_body_typed([](Integer size_hint_bytes, Integer clock_frequency_hz,
+ Integer read_bandwidth_bytes_per_cycle,
+ Integer write_bandwidth_bytes_per_cycle, Integer
read_latency_cycles,
+ Integer write_latency_cycles, Map<Target, Integer>
target_burst_bytes) {
+ return PoolInfoProperties(size_hint_bytes, clock_frequency_hz,
read_bandwidth_bytes_per_cycle,
+ write_bandwidth_bytes_per_cycle,
read_latency_cycles,
+ write_latency_cycles, target_burst_bytes,
Bool(false));
+ });
+
+TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
+ .set_dispatch<PoolInfoPropertiesNode>([](const ObjectRef& ref,
ReprPrinter* p) {
+ auto* node = static_cast<const PoolInfoPropertiesNode*>(ref.get());
+ p->stream << "PoolInfoPropertiesNode(\n"
+ << " size_hint_bytes=" << node->size_hint_bytes
+ << ",\n clock_frequency_hz=" << node->clock_frequency_hz
+ << ",\n read_bandwidth_bytes_per_cycle=" <<
node->read_bandwidth_bytes_per_cycle
+ << ",\n write_bandwidth_bytes_per_cycle=" <<
node->write_bandwidth_bytes_per_cycle
+ << ",\n read_latency_cycles=" << node->read_latency_cycles
+ << ",\n write_latency_cycles=" << node->write_latency_cycles
+ << ",\n target_burst_bytes=" << node->target_burst_bytes <<
")";
+ });
+
+WorkspacePoolInfo::WorkspacePoolInfo(String pool_name, Array<Target> targets,
+ PoolInfoProperties properties) {
+ auto poolinfo_node = make_object<WorkspacePoolInfoNode>();
+ poolinfo_node->pool_name = pool_name;
+ poolinfo_node->size_hint_bytes = properties->size_hint_bytes;
+ poolinfo_node->targets = targets;
+ poolinfo_node->clock_frequency_hz = properties->clock_frequency_hz;
+ poolinfo_node->read_bandwidth_bytes_per_cycle =
properties->read_bandwidth_bytes_per_cycle;
+ poolinfo_node->write_bandwidth_bytes_per_cycle =
properties->write_bandwidth_bytes_per_cycle;
+ poolinfo_node->read_latency_cycles = properties->read_latency_cycles;
+ poolinfo_node->write_latency_cycles = properties->write_latency_cycles;
+ poolinfo_node->target_burst_bytes = properties->target_burst_bytes;
+ poolinfo_node->is_internal = properties->is_internal;
+ data_ = std::move(poolinfo_node);
+}
+
+TVM_REGISTER_NODE_TYPE(WorkspacePoolInfoNode);
+TVM_REGISTER_GLOBAL("ir.WorkspacePoolInfo")
+ .set_body_typed([](String pool_name, Array<Target> targets,
PoolInfoProperties properties) {
+ return WorkspacePoolInfo(pool_name, targets, properties);
+ });
+
+TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
+ .set_dispatch<WorkspacePoolInfoNode>([](const ObjectRef& ref, ReprPrinter*
p) {
+ auto* node = static_cast<const WorkspacePoolInfoNode*>(ref.get());
+ p->stream << "WorkspacePoolInfoNode(\n"
+ << " pool_name=" << node->pool_name << ",\n targets=" <<
node->targets
+ << ",\n size_hint_bytes=" << node->size_hint_bytes
+ << ",\n clock_frequency_hz=" << node->clock_frequency_hz
+ << ",\n read_bandwidth_bytes_per_cycle=" <<
node->read_bandwidth_bytes_per_cycle
+ << ",\n write_bandwidth_bytes_per_cycle=" <<
node->write_bandwidth_bytes_per_cycle
+ << ",\n read_latency_cycles=" << node->read_latency_cycles
+ << ",\n write_latency_cycles=" << node->write_latency_cycles
+ << ",\n target_burst_bytes=" << node->target_burst_bytes
+ << ",\n is_internal=" << node->is_internal << ")"
+ << "\n";
+ });
+
+ConstantInfo::ConstantInfo(String name_hint, Integer byte_offset,
runtime::NDArray data) {
+ auto constant_info_node = make_object<ConstantInfoNode>();
+ constant_info_node->name_hint = name_hint;
+ constant_info_node->byte_offset = byte_offset;
+ constant_info_node->data = data;
+ data_ = std::move(constant_info_node);
+}
+
+TVM_REGISTER_NODE_TYPE(ConstantInfoNode);
+TVM_REGISTER_GLOBAL("tir.usmp.ConstantInfo")
Review Comment:
here as well
##########
include/tvm/ir/memory_pools.h:
##########
@@ -129,18 +128,166 @@ static const int kUnknownReadBandwidth = -1;
/*! \brief The write bandwidth is not known */
static const int kUnknownWriteBandwidth = -1;
+/*! \brief Base class for WorkspacePoolInfo and ConstantPoolInfo */
class PoolInfo : public ObjectRef {
- public:
- TVM_DLL PoolInfo(String pool_name, Map<Target, String> target_access,
- Integer size_hint_bytes = kUnrestrictedPoolSizeHint,
+ protected:
+ TVM_DLL PoolInfo(String pool_name, Integer size_hint_bytes =
kUnrestrictedPoolSizeHint,
Integer clock_frequency_hz = kUnknownClockFrequency,
Integer read_bandwidth_bytes_per_cycle =
kUnknownReadBandwidth,
Integer write_bandwidth_bytes_per_cycle =
kUnknownWriteBandwidth,
Integer read_latency_cycles = 0, Integer
write_latency_cycles = 0,
Map<Target, Integer> target_burst_bytes = {}, Bool
is_internal = Bool(false));
- TVM_DEFINE_MUTABLE_OBJECT_REF_METHODS(PoolInfo, ObjectRef, PoolInfoNode);
+
+ public:
+ TVM_DEFINE_OBJECT_REF_METHODS(PoolInfo, ObjectRef, PoolInfoNode);
+};
+
+/*!
+ * \brief Describes a pool of memory properties
+ */
+struct PoolInfoPropertiesNode : public Object {
+ /*! \brief The expected size hint to be used by the allocator.
+ * The size_hint_bytes is set to kUnrestrictedPoolSizeHint
+ * to indicate the pool is not size restricted.
+ */
+ Integer size_hint_bytes = kUnrestrictedPoolSizeHint;
+ /*! \brief The clock frequency of the memory in Hz */
+ Integer clock_frequency_hz = kUnknownClockFrequency;
+ /*! \brief The read bandwidth in bytes/cycle */
+ Integer read_bandwidth_bytes_per_cycle = kUnknownReadBandwidth;
+ /*! \brief The write bandwidth in bytes/cycle */
+ Integer write_bandwidth_bytes_per_cycle = kUnknownWriteBandwidth;
+ /*! \brief The read latency in cycles */
+ Integer read_latency_cycles = 0;
+ /*! \brief The write latency in cycles */
+ Integer write_latency_cycles = 0;
+ /*! \brief The burst length in bytes for each Target */
+ Map<Target, Integer> target_burst_bytes{};
+ /*! \brief Whether pool is internally generated.
+ * The internal pools will be generated as part of
+ * the entry point code generation of the executor
+ */
+ bool is_internal = false;
+
+ void VisitAttrs(tvm::AttrVisitor* v) {
+ v->Visit("size_hint_bytes", &size_hint_bytes);
+ v->Visit("clock_frequency_hz", &clock_frequency_hz);
+ v->Visit("read_bandwidth_bytes_per_cycle",
&read_bandwidth_bytes_per_cycle);
+ v->Visit("write_bandwidth_bytes_per_cycle",
&write_bandwidth_bytes_per_cycle);
+ v->Visit("read_latency_cycles", &read_latency_cycles);
+ v->Visit("write_latency_cycles", &write_latency_cycles);
+ v->Visit("target_burst_bytes", &target_burst_bytes);
+ v->Visit("is_internal", &is_internal);
+ }
+
+ bool SEqualReduce(const PoolInfoPropertiesNode* other, SEqualReducer equal)
const {
+ return equal(size_hint_bytes, other->size_hint_bytes) &&
+ equal(clock_frequency_hz, other->clock_frequency_hz) &&
+ equal(read_bandwidth_bytes_per_cycle,
other->read_bandwidth_bytes_per_cycle) &&
+ equal(write_bandwidth_bytes_per_cycle,
other->write_bandwidth_bytes_per_cycle) &&
+ equal(read_latency_cycles, other->read_latency_cycles) &&
+ equal(write_latency_cycles, other->write_latency_cycles) &&
+ equal(target_burst_bytes, other->target_burst_bytes) &&
+ equal(is_internal, other->is_internal);
+ }
+
+ void SHashReduce(SHashReducer hash_reduce) const {
+ hash_reduce(size_hint_bytes);
+ hash_reduce(clock_frequency_hz);
+ hash_reduce(read_bandwidth_bytes_per_cycle);
+ hash_reduce(write_bandwidth_bytes_per_cycle);
+ hash_reduce(read_latency_cycles);
+ hash_reduce(write_latency_cycles);
+ hash_reduce(target_burst_bytes);
+ hash_reduce(is_internal);
+ }
+
+ static constexpr const char* _type_key = "ir.PoolInfoProperties";
+ TVM_DECLARE_FINAL_OBJECT_INFO(PoolInfoPropertiesNode, Object);
};
+class PoolInfoProperties : public ObjectRef {
+ public:
+ TVM_DLL PoolInfoProperties(Integer size_hint_bytes,
+ Integer clock_frequency_hz =
kUnknownClockFrequency,
+ Integer read_bandwidth_bytes_per_cycle =
kUnknownReadBandwidth,
+ Integer write_bandwidth_bytes_per_cycle =
kUnknownWriteBandwidth,
+ Integer read_latency_cycles = 0, Integer
write_latency_cycles = 0,
+ Map<Target, Integer> target_burst_bytes = {},
+ Bool is_internal = Bool(false));
+ TVM_DEFINE_MUTABLE_OBJECT_REF_METHODS(PoolInfoProperties, ObjectRef,
PoolInfoPropertiesNode);
+};
+
+/* \brief Represents RW memory area */
+struct WorkspacePoolInfoNode : public PoolInfoNode {
+ static constexpr const char* _type_key = "ir.WorkspacePoolInfo";
+ TVM_DECLARE_FINAL_OBJECT_INFO(WorkspacePoolInfoNode, PoolInfoNode);
+};
+
+class WorkspacePoolInfo : public PoolInfo {
+ public:
+ TVM_DLL WorkspacePoolInfo(
+ String pool_name, Array<Target> targets,
+ PoolInfoProperties properties =
PoolInfoProperties(kUnrestrictedPoolSizeHint));
+ TVM_DEFINE_MUTABLE_OBJECT_REF_METHODS(WorkspacePoolInfo, PoolInfo,
WorkspacePoolInfoNode);
+};
+
+/*
+ * \brief The ConstantInfoNode contains numeric literal in RO pool
+ * Used to initialise RO memory in ConstantPoolInfo
+ */
+struct ConstantInfoNode : public Object {
+ String name_hint;
+ Integer byte_offset;
+ runtime::NDArray data;
+
+ void VisitAttrs(tvm::AttrVisitor* v) {
+ v->Visit("name_hint", &name_hint);
+ v->Visit("byte_offset", &byte_offset);
+ v->Visit("data", &data);
+ }
+
+ bool SEqualReduce(const ConstantInfoNode* other, SEqualReducer equal) const {
+ return equal(name_hint, other->name_hint) && equal(byte_offset,
other->byte_offset) &&
+ equal(data, other->data);
+ }
+
+ void SHashReduce(SHashReducer hash_reduce) const {
+ hash_reduce(name_hint);
+ hash_reduce(byte_offset);
+ hash_reduce(data);
+ }
+
+ static constexpr const char* _type_key = "tir.usmp.ConstantInfo";
Review Comment:
this prefix needs fixing too
##########
include/tvm/ir/memory_pools.h:
##########
@@ -130,15 +129,159 @@ static const int kUnknownReadBandwidth = -1;
static const int kUnknownWriteBandwidth = -1;
class PoolInfo : public ObjectRef {
- public:
- TVM_DLL PoolInfo(String pool_name, Map<Target, String> target_access,
- Integer size_hint_bytes = kUnrestrictedPoolSizeHint,
+ protected:
+ TVM_DLL PoolInfo(String pool_name, Integer size_hint_bytes =
kUnrestrictedPoolSizeHint,
Integer clock_frequency_hz = kUnknownClockFrequency,
Integer read_bandwidth_bytes_per_cycle =
kUnknownReadBandwidth,
Integer write_bandwidth_bytes_per_cycle =
kUnknownWriteBandwidth,
Integer read_latency_cycles = 0, Integer
write_latency_cycles = 0,
Map<Target, Integer> target_burst_bytes = {}, Bool
is_internal = Bool(false));
- TVM_DEFINE_MUTABLE_OBJECT_REF_METHODS(PoolInfo, ObjectRef, PoolInfoNode);
+
+ public:
+ // TVM_DEFINE_MUTABLE_OBJECT_REF_METHODS(PoolInfo, ObjectRef, PoolInfoNode);
+ TVM_DEFINE_OBJECT_REF_METHODS(PoolInfo, ObjectRef, PoolInfoNode);
+};
+
+/*!
+ * \brief Describes a pool of memory properties
+ */
+struct PoolInfoPropertiesNode : public Object {
+ /*! \brief The expected size hint to be used by the allocator.
+ * The size_hint_bytes is set to kUnrestrictedPoolSizeHint
+ * to indicate the pool is not size restricted.
+ */
+ Integer size_hint_bytes = kUnrestrictedPoolSizeHint;
+ /*! \brief The clock frequency of the memory in Hz */
+ Integer clock_frequency_hz = kUnknownClockFrequency;
+ /*! \brief The read bandwidth in bytes/cycle */
+ Integer read_bandwidth_bytes_per_cycle = kUnknownReadBandwidth;
+ /*! \brief The write bandwidth in bytes/cycle */
+ Integer write_bandwidth_bytes_per_cycle = kUnknownWriteBandwidth;
+ /*! \brief The read latency in cycles */
+ Integer read_latency_cycles = 0;
+ /*! \brief The write latency in cycles */
+ Integer write_latency_cycles = 0;
+ /*! \brief The burst length in bytes for each Target */
+ Map<Target, Integer> target_burst_bytes{};
+ /*! \brief Whether pool is internally generated.
+ * The internal pools will be generated as part of
+ * the entry point code generation of the executor
+ */
+ bool is_internal = false;
+
+ void VisitAttrs(tvm::AttrVisitor* v) {
+ v->Visit("size_hint_bytes", &size_hint_bytes);
+ v->Visit("clock_frequency_hz", &clock_frequency_hz);
+ v->Visit("read_bandwidth_bytes_per_cycle",
&read_bandwidth_bytes_per_cycle);
+ v->Visit("write_bandwidth_bytes_per_cycle",
&write_bandwidth_bytes_per_cycle);
+ v->Visit("read_latency_cycles", &read_latency_cycles);
+ v->Visit("write_latency_cycles", &write_latency_cycles);
+ v->Visit("target_burst_bytes", &target_burst_bytes);
+ v->Visit("is_internal", &is_internal);
+ }
+
+ bool SEqualReduce(const PoolInfoPropertiesNode* other, SEqualReducer equal)
const {
+ return equal(size_hint_bytes, other->size_hint_bytes) &&
+ equal(clock_frequency_hz, other->clock_frequency_hz) &&
+ equal(read_bandwidth_bytes_per_cycle,
other->read_bandwidth_bytes_per_cycle) &&
+ equal(write_bandwidth_bytes_per_cycle,
other->write_bandwidth_bytes_per_cycle) &&
+ equal(read_latency_cycles, other->read_latency_cycles) &&
+ equal(write_latency_cycles, other->write_latency_cycles) &&
+ equal(target_burst_bytes, other->target_burst_bytes) &&
+ equal(is_internal, other->is_internal);
+ }
+
+ void SHashReduce(SHashReducer hash_reduce) const {
+ hash_reduce(size_hint_bytes);
+ hash_reduce(clock_frequency_hz);
+ hash_reduce(read_bandwidth_bytes_per_cycle);
+ hash_reduce(write_bandwidth_bytes_per_cycle);
+ hash_reduce(read_latency_cycles);
+ hash_reduce(write_latency_cycles);
+ hash_reduce(target_burst_bytes);
+ hash_reduce(is_internal);
+ }
+
+ static constexpr const char* _type_key = "ir.PoolInfoProperties";
+ TVM_DECLARE_FINAL_OBJECT_INFO(PoolInfoPropertiesNode, Object);
+};
+
+class PoolInfoProperties : public ObjectRef {
+ public:
+ TVM_DLL PoolInfoProperties(Integer size_hint_bytes,
+ Integer clock_frequency_hz =
kUnknownClockFrequency,
+ Integer read_bandwidth_bytes_per_cycle =
kUnknownReadBandwidth,
+ Integer write_bandwidth_bytes_per_cycle =
kUnknownWriteBandwidth,
+ Integer read_latency_cycles = 0, Integer
write_latency_cycles = 0,
+ Map<Target, Integer> target_burst_bytes = {},
+ Bool is_internal = Bool(false));
+ TVM_DEFINE_MUTABLE_OBJECT_REF_METHODS(PoolInfoProperties, ObjectRef,
PoolInfoPropertiesNode);
+};
+
+struct WorkspacePoolInfoNode : public PoolInfoNode {
+ static constexpr const char* _type_key = "ir.WorkspacePoolInfo";
+ TVM_DECLARE_FINAL_OBJECT_INFO(WorkspacePoolInfoNode, PoolInfoNode);
+};
+
+class WorkspacePoolInfo : public PoolInfo {
Review Comment:
the thing i don't like about this is that both `__init__` for
`WorkspacePoolInfo` and `ConstantPoolInfo` invoke
`__init_handle_by_constructor__`, and so does `__init__` in their Python base
class `PoolInfo`; pylint would tell you we should be calling
super().__init__(), but this would result in a double-call to
`__init_handle_by_constructor__` so you have to ignore pylint. That seems maybe
a bit too magical to include as a valid use case of the Object system. If we
could get the same effect with type composition, I would vote for that instead.
##########
src/target/source/source_module.cc:
##########
@@ -283,6 +291,55 @@ class CSourceCrtMetadataModuleNode : public
runtime::ModuleNode {
code_ << "}\n\n";
}
+ void GenerateConstantBuffer(const ConstantPoolInfoNode* pool_info, size_t
allocated_size) {
+ size_t offset = 0;
+ if (pool_info->constant_info_array.size() > 0) {
+ // Pool is RO, form an initialized struct
+ code_ << "__attribute__((section(\".rodata.tvm\"), ";
+ code_ << "))\n";
+ code_ << "static struct " << pool_info->pool_name << " {\n";
+ // emit struct field names
+ std::vector<ConstantInfo>
const_info_vec(pool_info->constant_info_array.begin(),
+
pool_info->constant_info_array.end());
+ std::sort(const_info_vec.begin(), const_info_vec.end(),
+ [](const ConstantInfo& a, const ConstantInfo& b) {
+ return a->byte_offset->value < b->byte_offset->value;
+ });
+ for (const auto& const_info : const_info_vec) {
+ const auto& data = const_info->data;
+ const auto& offs = const_info->byte_offset;
+ int64_t num_elements = std::accumulate(data.Shape().begin(),
data.Shape().end(), 1,
+ std::multiplies<int64_t>());
+ code_ << " ";
+ codegen_c_base_.PrintType(data.DataType(), code_);
+ code_ << " " << const_info->name_hint << "[" << num_elements
+ << "] __attribute__((packed, aligned(" <<
metadata_->constant_alignment << ")));";
+ code_ << " // " << num_elements * data.DataType().bytes()
+ << " bytes, aligned offset: " << offs << "\n";
+ }
+ code_ << "} " << pool_info->pool_name << " = {\n";
+
+ // emit struct field initialization data
+ for (const auto& const_info : const_info_vec) {
+ code_ << " ." << const_info->name_hint << " = {\n";
+ codegen::NDArrayDataToC(const_info->data, 4, code_);
+ code_ << " },\n";
+ }
+ code_ << "};";
+ code_ << "// of total size " << allocated_size << " bytes, aligned: " <<
offset << " bytes\n";
+ } else {
+ LOG(FATAL) << "No constant data in constant pool found "
+ << PrettyPrint(GetRef<ObjectRef>(pool_info));
+ }
+ }
+
+ void GenerateWorkspaceBuffer(const WorkspacePoolInfoNode* pool_info, size_t
allocated_size) {
+ code_ << "__attribute__((section(\".bss.noinit.tvm\"), ";
Review Comment:
agreed this could be a follow up.
##########
python/tvm/ir/memory_pools.py:
##########
@@ -112,15 +112,155 @@ def __init__(
)
+@register_object("ir.PoolInfoProperties")
+class PoolInfoProperties(Object):
+ """PoolInfo object holds information related to memory pools
+ where the statically sized allocate nodes will pooled into.
+
+ Parameters
+ ----------
+ size_hint_bytes : Optional[int]
+ The expected size hint to be used by the allocator.
+ The default value would be -1 which means the pool
+ is not size restricted.
+
+ clock_frequency_hz : Optional[int]
+ The clock frequency that the memory pool runs at in Hz.
+ If not specified/known, this will default to -1 indicating
+ it hasn't been defined.
+
+ read_bandwidth_bytes_per_cycle : Optional[int]
+ The read bandwidth of the memory pool in bytes/cycle.
+ If not specified/known, this will default to -1 indicating
+ it hasn't been defined.
+
+ write_bandwidth_bytes_per_cycle : Optional[int]
+ The write bandwidth of the memory pool in bytes/cycle.
+ If not specified/known, this will default to -1 indicating
+ it hasn't been defined.
+
+ read_latency_cycles : Optional[int]
+ The read latency of the memory pool in cycles.
+ If not specified/known, this will default to 0.
+
+ write_latency_cycles : Optional[int]
+ The write latency of the memory pool in cycles.
+ If not specified/known, this will default to 0.
+
+ target_burst_bytes : Optional[Union[Dict[Target, int], None]]
+ The burst length of the memory pool in bytes per target.
+ If not specified/known for a given target, a burst length
+ of 1 byte will be assumed.
+
+ """
+
+ def __init__(
+ self,
+ size_hint_bytes: Optional[int] = -1,
+ clock_frequency_hz: Optional[int] = -1,
+ read_bandwidth_bytes_per_cycle: Optional[int] = -1,
+ write_bandwidth_bytes_per_cycle: Optional[int] = -1,
+ read_latency_cycles: Optional[int] = 0,
+ write_latency_cycles: Optional[int] = 0,
+ target_burst_bytes=None, # Optional[Union[Dict[target.Target, int],
None]]
+ ):
+ if not target_burst_bytes:
+ target_burst_bytes = dict()
+
+ self.__init_handle_by_constructor__(
+ _ffi_api.PoolInfoProperties, # type: ignore # pylint:
disable=no-member
+ size_hint_bytes,
+ clock_frequency_hz,
+ read_bandwidth_bytes_per_cycle,
+ write_bandwidth_bytes_per_cycle,
+ read_latency_cycles,
+ write_latency_cycles,
+ target_burst_bytes,
+ )
+
+
+@register_object("ir.WorkspacePoolInfo")
+class WorkspacePoolInfo(PoolInfo):
+ """WorkspacePoolInfo object holds information related to RW memory pools
+ where the statically sized allocate nodes will pooled into.
+
+ Parameters
+ ----------
+ pool_name : str
+ The name of the memory pool
+
+ targets : list[Target]
+ A list of targets which could access the pool
+
+ pool_info_properties : PoolInfoProperties
+ The properties of the pool.
+ """
+
+ # pylint: disable=W0231
+ def __init__(
+ self,
+ pool_name: str,
+ targets, # Dict[Target, str]
+ pool_info_properties=None,
+ ):
+ if pool_info_properties is None:
+ pool_info_properties = PoolInfoProperties()
+
+ self.__init_handle_by_constructor__(
+ _ffi_api.WorkspacePoolInfo, # type: ignore # pylint:
disable=no-member
+ pool_name,
+ targets,
+ pool_info_properties,
+ )
+
+
+@register_object("ir.ConstantPoolInfo")
+class ConstantPoolInfo(PoolInfo):
+ """ConstantPoolInfo object holds information related to RO memory pools
+ where the statically sized allocate nodes will pooled into.
+
+ Parameters
+ ----------
+ pool_name : str
+ The name of the memory pool
+
+ targets : list[Target]
+ describes which targets could access the pool
+
+ pool_info_properties : PoolInfoProperties
+ The properties of the pool.
+ """
+
+ # pylint: disable=W0231
+ def __init__(
+ self,
+ pool_name: str,
+ targets, # list[Target]
Review Comment:
i think you can also quote these to make a forward reference:
https://peps.python.org/pep-0484/#runtime-or-type-checking and see
https://peps.python.org/pep-0563/
could you either make the type annotation or remove the comment, here and
below
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
