[hipDNN] Add RMSNorm support to hipDNN frontend (#4823)

## Summary

- Adds RMSNorm (Root Mean Square Normalization) frontend API to hipDNN
- FlatBuffer schema (`rmsnorm_attributes.fbs`) with x, scale, epsilon, y
(required) and inv_rms, bias (optional)
- Frontend `RmsnormAttributes` class with serialization/deserialization
- Frontend `RmsnormNode` with validation and property inference
- JSON serialization support
- 25 unit tests across frontend, data SDK, and test SDK (all passing)

## Details

RMSNorm normalizes by root mean square without mean subtraction: `y = x
/ sqrt(mean(x^2) + epsilon) * scale`. This PR adds the frontend graph
support — the reference implementation will follow in a stacked PR
(ALMIOPEN-1098).

---
Generated by `/orchestrate`

[ALMIOPEN-1096]:
https://amd-hub.atlassian.net/browse/ALMIOPEN-1096?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Bibek Ghimire <bghimire@amd.com>

Author: 3 people

projects/hipdnn/data_sdk/CMakeLists.txt

@@ -158,6 +158,7 @@ if(HIPDNN_GENERATE_SDK_HEADERS)
             schemas/matmul_attributes.fbs
             schemas/norm_common.fbs
             schemas/pointwise_attributes.fbs
+            schemas/rmsnorm_attributes.fbs
             schemas/tensor_attributes.fbs
         SCHEMAS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/schemas"
         PRIMARY_VERSION ${HIPDNN_FLATBUFFERS_VERSION}

projects/hipdnn/data_sdk/include/hipdnn_data_sdk/data_objects/norm_common_generated.h

@@ -0,0 +1,56 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_NORMCOMMON_HIPDNN_DATA_SDK_DATA_OBJECTS_H_
+#define FLATBUFFERS_GENERATED_NORMCOMMON_HIPDNN_DATA_SDK_DATA_OBJECTS_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 9 &&
+              FLATBUFFERS_VERSION_REVISION == 23,
+             "Non-compatible flatbuffers version included");
+
+
+namespace hipdnn_data_sdk {
+namespace data_objects {
+
+enum class NormFwdPhase : int8_t {
+  NOT_SET = 0,
+  INFERENCE = 1,
+  TRAINING = 2,
+  MIN = NOT_SET,
+  MAX = TRAINING
+};
+
+inline const NormFwdPhase (&EnumValuesNormFwdPhase())[3] {
+  static const NormFwdPhase values[] = {
+    NormFwdPhase::NOT_SET,
+    NormFwdPhase::INFERENCE,
+    NormFwdPhase::TRAINING
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesNormFwdPhase() {
+  static const char * const names[4] = {
+    "NOT_SET",
+    "INFERENCE",
+    "TRAINING",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameNormFwdPhase(NormFwdPhase e) {
+  if (::flatbuffers::IsOutRange(e, NormFwdPhase::NOT_SET, NormFwdPhase::TRAINING)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesNormFwdPhase()[index];
+}
+
+}  // namespace data_objects
+}  // namespace hipdnn_data_sdk
+
+#endif  // FLATBUFFERS_GENERATED_NORMCOMMON_HIPDNN_DATA_SDK_DATA_OBJECTS_H_

projects/hipdnn/data_sdk/include/hipdnn_data_sdk/data_objects/rmsnorm_attributes_generated.h

@@ -0,0 +1,231 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_RMSNORMATTRIBUTES_HIPDNN_DATA_SDK_DATA_OBJECTS_H_
+#define FLATBUFFERS_GENERATED_RMSNORMATTRIBUTES_HIPDNN_DATA_SDK_DATA_OBJECTS_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 9 &&
+              FLATBUFFERS_VERSION_REVISION == 23,
+             "Non-compatible flatbuffers version included");
+
+#include "norm_common_generated.h"
+
+namespace hipdnn_data_sdk {
+namespace data_objects {
+
+struct RMSNormAttributes;
+struct RMSNormAttributesBuilder;
+struct RMSNormAttributesT;
+
+bool operator==(const RMSNormAttributesT &lhs, const RMSNormAttributesT &rhs);
+bool operator!=(const RMSNormAttributesT &lhs, const RMSNormAttributesT &rhs);
+
+struct RMSNormAttributesT : public ::flatbuffers::NativeTable {
+  typedef RMSNormAttributes TableType;
+  int64_t x_tensor_uid = 0;
+  int64_t scale_tensor_uid = 0;
+  int64_t epsilon_tensor_uid = 0;
+  int64_t y_tensor_uid = 0;
+  ::flatbuffers::Optional<int64_t> bias_tensor_uid = ::flatbuffers::nullopt;
+  ::flatbuffers::Optional<int64_t> inv_rms_tensor_uid = ::flatbuffers::nullopt;
+  hipdnn_data_sdk::data_objects::NormFwdPhase forward_phase = hipdnn_data_sdk::data_objects::NormFwdPhase::NOT_SET;
+};
+
+struct RMSNormAttributes FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef RMSNormAttributesT NativeTableType;
+  typedef RMSNormAttributesBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_X_TENSOR_UID = 4,
+    VT_SCALE_TENSOR_UID = 6,
+    VT_EPSILON_TENSOR_UID = 8,
+    VT_Y_TENSOR_UID = 10,
+    VT_BIAS_TENSOR_UID = 12,
+    VT_INV_RMS_TENSOR_UID = 14,
+    VT_FORWARD_PHASE = 16
+  };
+  int64_t x_tensor_uid() const {
+    return GetField<int64_t>(VT_X_TENSOR_UID, 0);
+  }
+  bool mutate_x_tensor_uid(int64_t _x_tensor_uid = 0) {
+    return SetField<int64_t>(VT_X_TENSOR_UID, _x_tensor_uid, 0);
+  }
+  int64_t scale_tensor_uid() const {
+    return GetField<int64_t>(VT_SCALE_TENSOR_UID, 0);
+  }
+  bool mutate_scale_tensor_uid(int64_t _scale_tensor_uid = 0) {
+    return SetField<int64_t>(VT_SCALE_TENSOR_UID, _scale_tensor_uid, 0);
+  }
+  int64_t epsilon_tensor_uid() const {
+    return GetField<int64_t>(VT_EPSILON_TENSOR_UID, 0);
+  }
+  bool mutate_epsilon_tensor_uid(int64_t _epsilon_tensor_uid = 0) {
+    return SetField<int64_t>(VT_EPSILON_TENSOR_UID, _epsilon_tensor_uid, 0);
+  }
+  int64_t y_tensor_uid() const {
+    return GetField<int64_t>(VT_Y_TENSOR_UID, 0);
+  }
+  bool mutate_y_tensor_uid(int64_t _y_tensor_uid = 0) {
+    return SetField<int64_t>(VT_Y_TENSOR_UID, _y_tensor_uid, 0);
+  }
+  ::flatbuffers::Optional<int64_t> bias_tensor_uid() const {
+    return GetOptional<int64_t, int64_t>(VT_BIAS_TENSOR_UID);
+  }
+  bool mutate_bias_tensor_uid(int64_t _bias_tensor_uid) {
+    return SetField<int64_t>(VT_BIAS_TENSOR_UID, _bias_tensor_uid);
+  }
+  ::flatbuffers::Optional<int64_t> inv_rms_tensor_uid() const {
+    return GetOptional<int64_t, int64_t>(VT_INV_RMS_TENSOR_UID);
+  }
+  bool mutate_inv_rms_tensor_uid(int64_t _inv_rms_tensor_uid) {
+    return SetField<int64_t>(VT_INV_RMS_TENSOR_UID, _inv_rms_tensor_uid);
+  }
+  hipdnn_data_sdk::data_objects::NormFwdPhase forward_phase() const {
+    return static_cast<hipdnn_data_sdk::data_objects::NormFwdPhase>(GetField<int8_t>(VT_FORWARD_PHASE, 0));
+  }
+  bool mutate_forward_phase(hipdnn_data_sdk::data_objects::NormFwdPhase _forward_phase = static_cast<hipdnn_data_sdk::data_objects::NormFwdPhase>(0)) {
+    return SetField<int8_t>(VT_FORWARD_PHASE, static_cast<int8_t>(_forward_phase), 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_X_TENSOR_UID, 8) &&
+           VerifyField<int64_t>(verifier, VT_SCALE_TENSOR_UID, 8) &&
+           VerifyField<int64_t>(verifier, VT_EPSILON_TENSOR_UID, 8) &&
+           VerifyField<int64_t>(verifier, VT_Y_TENSOR_UID, 8) &&
+           VerifyField<int64_t>(verifier, VT_BIAS_TENSOR_UID, 8) &&
+           VerifyField<int64_t>(verifier, VT_INV_RMS_TENSOR_UID, 8) &&
+           VerifyField<int8_t>(verifier, VT_FORWARD_PHASE, 1) &&
+           verifier.EndTable();
+  }
+  RMSNormAttributesT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(RMSNormAttributesT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<RMSNormAttributes> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RMSNormAttributesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct RMSNormAttributesBuilder {
+  typedef RMSNormAttributes Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_x_tensor_uid(int64_t x_tensor_uid) {
+    fbb_.AddElement<int64_t>(RMSNormAttributes::VT_X_TENSOR_UID, x_tensor_uid, 0);
+  }
+  void add_scale_tensor_uid(int64_t scale_tensor_uid) {
+    fbb_.AddElement<int64_t>(RMSNormAttributes::VT_SCALE_TENSOR_UID, scale_tensor_uid, 0);
+  }
+  void add_epsilon_tensor_uid(int64_t epsilon_tensor_uid) {
+    fbb_.AddElement<int64_t>(RMSNormAttributes::VT_EPSILON_TENSOR_UID, epsilon_tensor_uid, 0);
+  }
+  void add_y_tensor_uid(int64_t y_tensor_uid) {
+    fbb_.AddElement<int64_t>(RMSNormAttributes::VT_Y_TENSOR_UID, y_tensor_uid, 0);
+  }
+  void add_bias_tensor_uid(int64_t bias_tensor_uid) {
+    fbb_.AddElement<int64_t>(RMSNormAttributes::VT_BIAS_TENSOR_UID, bias_tensor_uid);
+  }
+  void add_inv_rms_tensor_uid(int64_t inv_rms_tensor_uid) {
+    fbb_.AddElement<int64_t>(RMSNormAttributes::VT_INV_RMS_TENSOR_UID, inv_rms_tensor_uid);
+  }
+  void add_forward_phase(hipdnn_data_sdk::data_objects::NormFwdPhase forward_phase) {
+    fbb_.AddElement<int8_t>(RMSNormAttributes::VT_FORWARD_PHASE, static_cast<int8_t>(forward_phase), 0);
+  }
+  explicit RMSNormAttributesBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<RMSNormAttributes> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<RMSNormAttributes>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<RMSNormAttributes> CreateRMSNormAttributes(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t x_tensor_uid = 0,
+    int64_t scale_tensor_uid = 0,
+    int64_t epsilon_tensor_uid = 0,
+    int64_t y_tensor_uid = 0,
+    ::flatbuffers::Optional<int64_t> bias_tensor_uid = ::flatbuffers::nullopt,
+    ::flatbuffers::Optional<int64_t> inv_rms_tensor_uid = ::flatbuffers::nullopt,
+    hipdnn_data_sdk::data_objects::NormFwdPhase forward_phase = hipdnn_data_sdk::data_objects::NormFwdPhase::NOT_SET) {
+  RMSNormAttributesBuilder builder_(_fbb);
+  if(inv_rms_tensor_uid) { builder_.add_inv_rms_tensor_uid(*inv_rms_tensor_uid); }
+  if(bias_tensor_uid) { builder_.add_bias_tensor_uid(*bias_tensor_uid); }
+  builder_.add_y_tensor_uid(y_tensor_uid);
+  builder_.add_epsilon_tensor_uid(epsilon_tensor_uid);
+  builder_.add_scale_tensor_uid(scale_tensor_uid);
+  builder_.add_x_tensor_uid(x_tensor_uid);
+  builder_.add_forward_phase(forward_phase);
+  return builder_.Finish();
+}
+
+::flatbuffers::Offset<RMSNormAttributes> CreateRMSNormAttributes(::flatbuffers::FlatBufferBuilder &_fbb, const RMSNormAttributesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+
+inline bool operator==(const RMSNormAttributesT &lhs, const RMSNormAttributesT &rhs) {
+  return
+      (lhs.x_tensor_uid == rhs.x_tensor_uid) &&
+      (lhs.scale_tensor_uid == rhs.scale_tensor_uid) &&
+      (lhs.epsilon_tensor_uid == rhs.epsilon_tensor_uid) &&
+      (lhs.y_tensor_uid == rhs.y_tensor_uid) &&
+      (lhs.bias_tensor_uid == rhs.bias_tensor_uid) &&
+      (lhs.inv_rms_tensor_uid == rhs.inv_rms_tensor_uid) &&
+      (lhs.forward_phase == rhs.forward_phase);
+}
+
+inline bool operator!=(const RMSNormAttributesT &lhs, const RMSNormAttributesT &rhs) {
+    return !(lhs == rhs);
+}
+
+
+inline RMSNormAttributesT *RMSNormAttributes::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<RMSNormAttributesT>(new RMSNormAttributesT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void RMSNormAttributes::UnPackTo(RMSNormAttributesT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = x_tensor_uid(); _o->x_tensor_uid = _e; }
+  { auto _e = scale_tensor_uid(); _o->scale_tensor_uid = _e; }
+  { auto _e = epsilon_tensor_uid(); _o->epsilon_tensor_uid = _e; }
+  { auto _e = y_tensor_uid(); _o->y_tensor_uid = _e; }
+  { auto _e = bias_tensor_uid(); _o->bias_tensor_uid = _e; }
+  { auto _e = inv_rms_tensor_uid(); _o->inv_rms_tensor_uid = _e; }
+  { auto _e = forward_phase(); _o->forward_phase = _e; }
+}
+
+inline ::flatbuffers::Offset<RMSNormAttributes> RMSNormAttributes::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RMSNormAttributesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateRMSNormAttributes(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<RMSNormAttributes> CreateRMSNormAttributes(::flatbuffers::FlatBufferBuilder &_fbb, const RMSNormAttributesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RMSNormAttributesT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _x_tensor_uid = _o->x_tensor_uid;
+  auto _scale_tensor_uid = _o->scale_tensor_uid;
+  auto _epsilon_tensor_uid = _o->epsilon_tensor_uid;
+  auto _y_tensor_uid = _o->y_tensor_uid;
+  auto _bias_tensor_uid = _o->bias_tensor_uid;
+  auto _inv_rms_tensor_uid = _o->inv_rms_tensor_uid;
+  auto _forward_phase = _o->forward_phase;
+  return hipdnn_data_sdk::data_objects::CreateRMSNormAttributes(
+      _fbb,
+      _x_tensor_uid,
+      _scale_tensor_uid,
+      _epsilon_tensor_uid,
+      _y_tensor_uid,
+      _bias_tensor_uid,
+      _inv_rms_tensor_uid,
+      _forward_phase);
+}
+
+}  // namespace data_objects
+}  // namespace hipdnn_data_sdk
+
+#endif  // FLATBUFFERS_GENERATED_RMSNORMATTRIBUTES_HIPDNN_DATA_SDK_DATA_OBJECTS_H_