[serialization_lib] Remove unused type field from Pad and Clamp

This patch removes the "type" field from PadAttribute and ClampAttribute
because they are unused and unneeded.

Signed-off-by: Tai Ly <tai.ly@arm.com>
Change-Id: I378291b340ecee86824f25b3887aa4511207db23

6 files changed, 16 insertions, 74 deletions

diff --git a/include/attribute.def b/include/attribute.def
index 30b432d..723543e 100644
--- a/include/attribute.def
+++ b/include/attribute.def
@@ -52,9 +52,8 @@ DEF_ATTRIBUTE(TransposeConv, 7,
               bool,    S, local_bound,
               DType,   S, acc_type)
 
-DEF_ATTRIBUTE(Pad, 2,
-              uint8_t, V, pad_const,
-              DType,   S, type)
+DEF_ATTRIBUTE(Pad, 1,
+              uint8_t, V, pad_const)
 
 DEF_ATTRIBUTE(Axis, 1,
               int32_t, S, axis)
@@ -65,10 +64,9 @@ DEF_ATTRIBUTE(Resize, 4,
               int16_t, V, border,
               ResizeMode, S, mode)
 
-DEF_ATTRIBUTE(Clamp, 3,
+DEF_ATTRIBUTE(Clamp, 2,
               uint8_t, V, min_val,
-              uint8_t, V, max_val,
-              DType,   S, type)
+              uint8_t, V, max_val)
 
 DEF_ATTRIBUTE(Rescale, 7,
               int32_t, S, input_zp,
diff --git a/include/tosa_generated.h b/include/tosa_generated.h
index 0798256..20f6993 100644
--- a/include/tosa_generated.h
+++ b/include/tosa_generated.h
@@ -1008,20 +1008,15 @@ inline ::flatbuffers::Offset<TransposeConvAttribute> CreateTransposeConvAttribut
 struct PadAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef PadAttributeBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_PAD_CONST = 4,
-    VT_TYPE = 6
+    VT_PAD_CONST = 4
   };
   const ::flatbuffers::Vector<uint8_t> *pad_const() const {
     return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PAD_CONST);
   }
-  tosa::DType type() const {
-    return static_cast<tosa::DType>(GetField<uint32_t>(VT_TYPE, 0));
-  }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_PAD_CONST) &&
            verifier.VerifyVector(pad_const()) &&
-           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
            verifier.EndTable();
   }
 };
@@ -1033,9 +1028,6 @@ struct PadAttributeBuilder {
   void add_pad_const(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> pad_const) {
     fbb_.AddOffset(PadAttribute::VT_PAD_CONST, pad_const);
   }
-  void add_type(tosa::DType type) {
-    fbb_.AddElement<uint32_t>(PadAttribute::VT_TYPE, static_cast<uint32_t>(type), 0);
-  }
   explicit PadAttributeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -1049,24 +1041,20 @@ struct PadAttributeBuilder {
 
 inline ::flatbuffers::Offset<PadAttribute> CreatePadAttribute(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> pad_const = 0,
-    tosa::DType type = tosa::DType_UNKNOWN) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> pad_const = 0) {
   PadAttributeBuilder builder_(_fbb);
-  builder_.add_type(type);
   builder_.add_pad_const(pad_const);
   return builder_.Finish();
 }
 
 inline ::flatbuffers::Offset<PadAttribute> CreatePadAttributeDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<uint8_t> *pad_const = nullptr,
-    tosa::DType type = tosa::DType_UNKNOWN) {
+    const std::vector<uint8_t> *pad_const = nullptr) {
   if (pad_const) { _fbb.ForceVectorAlignment(pad_const->size(), sizeof(uint8_t), 8); }
   auto pad_const__ = pad_const ? _fbb.CreateVector<uint8_t>(*pad_const) : 0;
   return tosa::CreatePadAttribute(
       _fbb,
-      pad_const__,
-      type);
+      pad_const__);
 }
 
 struct AxisAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -1205,8 +1193,7 @@ struct ClampAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef ClampAttributeBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_MIN_VAL = 4,
-    VT_MAX_VAL = 6,
-    VT_TYPE = 8
+    VT_MAX_VAL = 6
   };
   const ::flatbuffers::Vector<uint8_t> *min_val() const {
     return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MIN_VAL);
@@ -1214,16 +1201,12 @@ struct ClampAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<uint8_t> *max_val() const {
     return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MAX_VAL);
   }
-  tosa::DType type() const {
-    return static_cast<tosa::DType>(GetField<uint32_t>(VT_TYPE, 0));
-  }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_MIN_VAL) &&
            verifier.VerifyVector(min_val()) &&
            VerifyOffset(verifier, VT_MAX_VAL) &&
            verifier.VerifyVector(max_val()) &&
-           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
            verifier.EndTable();
   }
 };
@@ -1238,9 +1221,6 @@ struct ClampAttributeBuilder {
   void add_max_val(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> max_val) {
     fbb_.AddOffset(ClampAttribute::VT_MAX_VAL, max_val);
   }
-  void add_type(tosa::DType type) {
-    fbb_.AddElement<uint32_t>(ClampAttribute::VT_TYPE, static_cast<uint32_t>(type), 0);
-  }
   explicit ClampAttributeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -1255,10 +1235,8 @@ struct ClampAttributeBuilder {
 inline ::flatbuffers::Offset<ClampAttribute> CreateClampAttribute(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> min_val = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> max_val = 0,
-    tosa::DType type = tosa::DType_UNKNOWN) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> max_val = 0) {
   ClampAttributeBuilder builder_(_fbb);
-  builder_.add_type(type);
   builder_.add_max_val(max_val);
   builder_.add_min_val(min_val);
   return builder_.Finish();
@@ -1267,8 +1245,7 @@ inline ::flatbuffers::Offset<ClampAttribute> CreateClampAttribute(
 inline ::flatbuffers::Offset<ClampAttribute> CreateClampAttributeDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<uint8_t> *min_val = nullptr,
-    const std::vector<uint8_t> *max_val = nullptr,
-    tosa::DType type = tosa::DType_UNKNOWN) {
+    const std::vector<uint8_t> *max_val = nullptr) {
   if (min_val) { _fbb.ForceVectorAlignment(min_val->size(), sizeof(uint8_t), 8); }
   auto min_val__ = min_val ? _fbb.CreateVector<uint8_t>(*min_val) : 0;
   if (max_val) { _fbb.ForceVectorAlignment(max_val->size(), sizeof(uint8_t), 8); }
@@ -1276,8 +1253,7 @@ inline ::flatbuffers::Offset<ClampAttribute> CreateClampAttributeDirect(
   return tosa::CreateClampAttribute(
       _fbb,
       min_val__,
-      max_val__,
-      type);
+      max_val__);
 }
 
 struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
diff --git a/python/serializer/tosa_serializer.py b/python/serializer/tosa_serializer.py
index 298907e..bbfb37e 100644
--- a/python/serializer/tosa_serializer.py
+++ b/python/serializer/tosa_serializer.py
@@ -205,7 +205,7 @@ class TosaSerializerAttribute(TosaSerializerUnion):
         self.bools.append((a.AddLocalBound, local_bound))
         self.ints.append((a.AddAccType, acc_type))
 
-    def PadAttribute(self, serializer_builder, pad_const_val_as_bytes, dtype):
+    def PadAttribute(self, serializer_builder, pad_const_val_as_bytes):
         from tosa import PadAttribute as a, Attribute
 
         self.utype = Attribute.Attribute().PadAttribute
@@ -217,7 +217,6 @@ class TosaSerializerAttribute(TosaSerializerUnion):
         )
 
         self.floats.append((a.AddPadConst, serialized_pad_const_val))
-        self.ints.append((a.AddType, dtype))
 
     def AxisAttribute(self, axis):
         from tosa import AxisAttribute as a, Attribute
@@ -238,9 +237,7 @@ class TosaSerializerAttribute(TosaSerializerUnion):
         self.int16vecs.append((a.AddBorder, border))
         self.ints.append((a.AddMode, mode))
 
-    def ClampAttribute(
-        self, serializer_builder, min_val_as_bytes, max_val_as_bytes, dtype
-    ):
+    def ClampAttribute(self, serializer_builder, min_val_as_bytes, max_val_as_bytes):
         from tosa import ClampAttribute as a, Attribute
 
         self.utype = Attribute.Attribute().ClampAttribute
@@ -256,7 +253,6 @@ class TosaSerializerAttribute(TosaSerializerUnion):
 
         self.floats.append((a.AddMinVal, serialized_min_val))
         self.floats.append((a.AddMaxVal, serialized_max_val))
-        self.ints.append((a.AddType, dtype))
 
     def RescaleAttribute(
         self,
diff --git a/python/tosa/ClampAttribute.py b/python/tosa/ClampAttribute.py
index 1189acb..6a41498 100644
--- a/python/tosa/ClampAttribute.py
+++ b/python/tosa/ClampAttribute.py
@@ -82,15 +82,8 @@ class ClampAttribute(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         return o == 0
 
-    # ClampAttribute
-    def Type(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
-        return 0
-
 def ClampAttributeStart(builder):
-    builder.StartObject(3)
+    builder.StartObject(2)
 
 def Start(builder):
     ClampAttributeStart(builder)
@@ -119,12 +112,6 @@ def ClampAttributeStartMaxValVector(builder, numElems):
 def StartMaxValVector(builder, numElems: int) -> int:
     return ClampAttributeStartMaxValVector(builder, numElems)
 
-def ClampAttributeAddType(builder, type):
-    builder.PrependUint32Slot(2, type, 0)
-
-def AddType(builder, type):
-    ClampAttributeAddType(builder, type)
-
 def ClampAttributeEnd(builder):
     return builder.EndObject()
 
diff --git a/python/tosa/PadAttribute.py b/python/tosa/PadAttribute.py
index c4084dc..301bf17 100644
--- a/python/tosa/PadAttribute.py
+++ b/python/tosa/PadAttribute.py
@@ -55,15 +55,8 @@ class PadAttribute(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         return o == 0
 
-    # PadAttribute
-    def Type(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
-        return 0
-
 def PadAttributeStart(builder):
-    builder.StartObject(2)
+    builder.StartObject(1)
 
 def Start(builder):
     PadAttributeStart(builder)
@@ -80,12 +73,6 @@ def PadAttributeStartPadConstVector(builder, numElems):
 def StartPadConstVector(builder, numElems: int) -> int:
     return PadAttributeStartPadConstVector(builder, numElems)
 
-def PadAttributeAddType(builder, type):
-    builder.PrependUint32Slot(1, type, 0)
-
-def AddType(builder, type):
-    PadAttributeAddType(builder, type)
-
 def PadAttributeEnd(builder):
     return builder.EndObject()
 
diff --git a/schema/tosa.fbs b/schema/tosa.fbs
index 7b5948b..79b83b1 100644
--- a/schema/tosa.fbs
+++ b/schema/tosa.fbs
@@ -185,7 +185,6 @@ table TransposeConvAttribute {
 
 table PadAttribute {
   pad_const: [ubyte] (force_align: 8);
-  type: DType;
 }
 
 table AxisAttribute {
@@ -202,7 +201,6 @@ table ResizeAttribute {
 table ClampAttribute {
   min_val: [ubyte] (force_align: 8);
   max_val: [ubyte] (force_align: 8);
-  type: DType;
 }
 
 table RescaleAttribute {