Schema changes for CLAMP, PAD float attributes

* Float attributes now serialized as uint8 vectors, but treated as floats at input/output to serialization

Signed-off-by: James Ward <james.ward@arm.com>
Change-Id: I417b0fabe0ef11fea263fe937b57d49bbfdb00da

2 files changed, 72 insertions, 21 deletions

diff --git a/include/attribute.h b/include/attribute.h
index 1178ee4..5371130 100644
--- a/include/attribute.h
+++ b/include/attribute.h
@@ -40,11 +40,39 @@ public:
     {}
 };
 
+inline int convertFlatbuffersU8toF32(const flatbuffers::Vector<uint8_t>& in, uint32_t out_size, std::vector<float>& out)
+{
+    out.clear();
+    if (in.size() < out_size * sizeof(float))
+    {
+        printf("convertFlatbuffersU8toF32(): uint8 Flatbuffers buffer size %u must be >= target size %ld\n", in.size(),
+               out_size * sizeof(float));
+        return 1;
+    }
+    for (uint32_t i = 0; i < out_size; i++)
+    {
+        uint32_t byte0   = in[i * sizeof(float)];
+        uint32_t byte1   = in[i * sizeof(float) + 1];
+        uint32_t byte2   = in[i * sizeof(float) + 2];
+        uint32_t byte3   = in[i * sizeof(float) + 3];
+        uint32_t val_u32 = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
+        float* val_fp32  = reinterpret_cast<float*>(&val_u32);
+        out.push_back(*val_fp32);
+    }
+    return 0;
+}
+
 #define DEF_ARGS_VER0_S_STR(V) _##V = p->V()->str();
 #define DEF_ARGS_VER0_S_DEFAULT(V) _##V = p->V();
+#define DEF_ARGS_VER0_S_float_as_bytes(V)                                                                              \
+    {                                                                                                                  \
+        std::vector<float> attr_vec;                                                                                   \
+        assert(!convertFlatbuffersU8toF32(*(p->V()), 1, attr_vec));                                                    \
+        _##V = attr_vec[0];                                                                                            \
+    }
 
 #define DEF_ARGS_VER0_S_int32_t(V) DEF_ARGS_VER0_S_DEFAULT(V)
-#define DEF_ARGS_VER0_S_float(V) DEF_ARGS_VER0_S_DEFAULT(V)
+#define DEF_ARGS_VER0_S_float(V) DEF_ARGS_VER0_S_float_as_bytes(V)
 #define DEF_ARGS_VER0_S_bool(V) DEF_ARGS_VER0_S_DEFAULT(V)
 #define DEF_ARGS_VER0_S_ResizeMode(V) DEF_ARGS_VER0_S_DEFAULT(V)
 #define DEF_ARGS_VER0_S_DType(V) DEF_ARGS_VER0_S_DEFAULT(V)
diff --git a/include/tosa_generated.h b/include/tosa_generated.h
index 1a79453..b34875f 100644
--- a/include/tosa_generated.h
+++ b/include/tosa_generated.h
@@ -968,15 +968,16 @@ struct PadAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int32_t pad_const_int() const {
     return GetField<int32_t>(VT_PAD_CONST_INT, 0);
   }
-  float pad_const_fp() const {
-    return GetField<float>(VT_PAD_CONST_FP, 0.0f);
+  const flatbuffers::Vector<uint8_t> *pad_const_fp() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PAD_CONST_FP);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_PADDING) &&
            verifier.VerifyVector(padding()) &&
            VerifyField<int32_t>(verifier, VT_PAD_CONST_INT, 4) &&
-           VerifyField<float>(verifier, VT_PAD_CONST_FP, 4) &&
+           VerifyOffset(verifier, VT_PAD_CONST_FP) &&
+           verifier.VerifyVector(pad_const_fp()) &&
            verifier.EndTable();
   }
 };
@@ -991,8 +992,8 @@ struct PadAttributeBuilder {
   void add_pad_const_int(int32_t pad_const_int) {
     fbb_.AddElement<int32_t>(PadAttribute::VT_PAD_CONST_INT, pad_const_int, 0);
   }
-  void add_pad_const_fp(float pad_const_fp) {
-    fbb_.AddElement<float>(PadAttribute::VT_PAD_CONST_FP, pad_const_fp, 0.0f);
+  void add_pad_const_fp(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pad_const_fp) {
+    fbb_.AddOffset(PadAttribute::VT_PAD_CONST_FP, pad_const_fp);
   }
   explicit PadAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
@@ -1009,7 +1010,7 @@ inline flatbuffers::Offset<PadAttribute> CreatePadAttribute(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0,
     int32_t pad_const_int = 0,
-    float pad_const_fp = 0.0f) {
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pad_const_fp = 0) {
   PadAttributeBuilder builder_(_fbb);
   builder_.add_pad_const_fp(pad_const_fp);
   builder_.add_pad_const_int(pad_const_int);
@@ -1021,13 +1022,15 @@ inline flatbuffers::Offset<PadAttribute> CreatePadAttributeDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<int32_t> *padding = nullptr,
     int32_t pad_const_int = 0,
-    float pad_const_fp = 0.0f) {
+    const std::vector<uint8_t> *pad_const_fp = nullptr) {
   auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
+  if (pad_const_fp) { _fbb.ForceVectorAlignment(pad_const_fp->size(), sizeof(uint8_t), 8); }
+  auto pad_const_fp__ = pad_const_fp ? _fbb.CreateVector<uint8_t>(*pad_const_fp) : 0;
   return tosa::CreatePadAttribute(
       _fbb,
       padding__,
       pad_const_int,
-      pad_const_fp);
+      pad_const_fp__);
 }
 
 struct AxisAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1343,18 +1346,20 @@ struct ClampAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int32_t max_int() const {
     return GetField<int32_t>(VT_MAX_INT, 0);
   }
-  float min_fp() const {
-    return GetField<float>(VT_MIN_FP, 0.0f);
+  const flatbuffers::Vector<uint8_t> *min_fp() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MIN_FP);
   }
-  float max_fp() const {
-    return GetField<float>(VT_MAX_FP, 0.0f);
+  const flatbuffers::Vector<uint8_t> *max_fp() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MAX_FP);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_MIN_INT, 4) &&
            VerifyField<int32_t>(verifier, VT_MAX_INT, 4) &&
-           VerifyField<float>(verifier, VT_MIN_FP, 4) &&
-           VerifyField<float>(verifier, VT_MAX_FP, 4) &&
+           VerifyOffset(verifier, VT_MIN_FP) &&
+           verifier.VerifyVector(min_fp()) &&
+           VerifyOffset(verifier, VT_MAX_FP) &&
+           verifier.VerifyVector(max_fp()) &&
            verifier.EndTable();
   }
 };
@@ -1369,11 +1374,11 @@ struct ClampAttributeBuilder {
   void add_max_int(int32_t max_int) {
     fbb_.AddElement<int32_t>(ClampAttribute::VT_MAX_INT, max_int, 0);
   }
-  void add_min_fp(float min_fp) {
-    fbb_.AddElement<float>(ClampAttribute::VT_MIN_FP, min_fp, 0.0f);
+  void add_min_fp(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> min_fp) {
+    fbb_.AddOffset(ClampAttribute::VT_MIN_FP, min_fp);
   }
-  void add_max_fp(float max_fp) {
-    fbb_.AddElement<float>(ClampAttribute::VT_MAX_FP, max_fp, 0.0f);
+  void add_max_fp(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> max_fp) {
+    fbb_.AddOffset(ClampAttribute::VT_MAX_FP, max_fp);
   }
   explicit ClampAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
@@ -1390,8 +1395,8 @@ inline flatbuffers::Offset<ClampAttribute> CreateClampAttribute(
     flatbuffers::FlatBufferBuilder &_fbb,
     int32_t min_int = 0,
     int32_t max_int = 0,
-    float min_fp = 0.0f,
-    float max_fp = 0.0f) {
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> min_fp = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> max_fp = 0) {
   ClampAttributeBuilder builder_(_fbb);
   builder_.add_max_fp(max_fp);
   builder_.add_min_fp(min_fp);
@@ -1400,6 +1405,24 @@ inline flatbuffers::Offset<ClampAttribute> CreateClampAttribute(
   return builder_.Finish();
 }
 
+inline flatbuffers::Offset<ClampAttribute> CreateClampAttributeDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t min_int = 0,
+    int32_t max_int = 0,
+    const std::vector<uint8_t> *min_fp = nullptr,
+    const std::vector<uint8_t> *max_fp = nullptr) {
+  if (min_fp) { _fbb.ForceVectorAlignment(min_fp->size(), sizeof(uint8_t), 8); }
+  auto min_fp__ = min_fp ? _fbb.CreateVector<uint8_t>(*min_fp) : 0;
+  if (max_fp) { _fbb.ForceVectorAlignment(max_fp->size(), sizeof(uint8_t), 8); }
+  auto max_fp__ = max_fp ? _fbb.CreateVector<uint8_t>(*max_fp) : 0;
+  return tosa::CreateClampAttribute(
+      _fbb,
+      min_int,
+      max_int,
+      min_fp__,
+      max_fp__);
+}
+
 struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef RescaleAttributeBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {