[CP] optimize large trans ctx limitation

deps/oblib/src/lib/utility/ob_tracepoint.h

@@ -509,13 +509,13 @@ public:
     EN_PARTICIPANTS_SIZE_OVERFLOW = 275,
     EN_UNDO_ACTIONS_SIZE_OVERFLOW = 276,
     EN_PART_PLUS_UNDO_OVERFLOW = 277,
+    EN_HANDLE_PREPARE_MESSAGE_EAGAIN = 278,
 
     EN_PREVENT_SYNC_REPORT = 360,
     EN_PREVENT_ASYNC_REPORT = 361,
 
     EN_LOG_IDS_COUNT_ERROR = 363,
 
-
     // DDL related 500-550
     EN_SUBMIT_INDEX_TASK_ERROR_BEFORE_STAT_RECORD = 503,
     EN_SUBMIT_INDEX_TASK_ERROR_AFTER_STAT_RECORD = 504,

src/share/parameter/ob_parameter_seed.ipp

@@ -1016,6 +1016,10 @@ DEF_BOOL(enable_election_group, OB_CLUSTER_PARAMETER, "True",
     "specifies whether election group is turned on. "
     "Value:  True:turned on;  False: turned off",
     ObParameterAttr(Section::OBSERVER, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
+DEF_BOOL(_enable_trans_ctx_size_limit, OB_TENANT_PARAMETER, "True",
+    "specifies whether trans ctx size limit is turned on or not. "
+    "Value: True:turned on;  False: turned off",
+    ObParameterAttr(Section::TENANT, Source::DEFAULT, EditLevel::DYNAMIC_EFFECTIVE));
 
 // Tablet config
 DEF_CAP_WITH_CHECKER(tablet_size, OB_CLUSTER_PARAMETER, "128M", common::ObConfigTabletSizeChecker,

src/storage/transaction/ob_trans_define.cpp

@@ -1419,34 +1419,47 @@ int ObTransDesc::merge_participants(const common::ObPartitionArray& participants
   return ret;
 }
 
+#ifdef ERRSIM
+#define INJECT_PARTICIPANTS_OVERFLOW_ERRSIM                                                                        \
+  do {                                                                                                             \
+    if (OB_FAIL(E(EventTable::EN_PARTICIPANTS_SIZE_OVERFLOW) OB_SUCCESS)) {                                        \
+      OB_MAX_TRANS_SERIALIZE_SIZE = 1500;                                                                          \
+      OB_MIN_REDO_LOG_SERIALIZE_SIZE = 500;                                                                        \
+    } else if (OB_FAIL(E(EventTable::EN_PART_PLUS_UNDO_OVERFLOW) OB_SUCCESS)) {                                    \
+      OB_MAX_TRANS_SERIALIZE_SIZE = 7500;                                                                          \
+      OB_MIN_REDO_LOG_SERIALIZE_SIZE = 500;                                                                        \
+    }                                                                                                              \
+                                                                                                                   \
+    transaction::OB_MAX_UNDO_ACTION_SERIALIZE_SIZE = OB_MAX_TRANS_SERIALIZE_SIZE - OB_MIN_REDO_LOG_SERIALIZE_SIZE; \
+                                                                                                                   \
+    TRANS_LOG(INFO,                                                                                                \
+        "ERRSIM modify trans ctx serialize size ",                                                                 \
+        K(OB_MAX_TRANS_SERIALIZE_SIZE),                                                                            \
+        K(OB_MIN_REDO_LOG_SERIALIZE_SIZE),                                                                         \
+        K(transaction::OB_MAX_UNDO_ACTION_SERIALIZE_SIZE));                                                        \
+                                                                                                                   \
+    ret = OB_SUCCESS;                                                                                              \
+  } while (false);
+#else
+#define INJECT_PARTICIPANTS_OVERFLOW_ERRSIM
+#endif
+
 int ObTransDesc::check_participants_size()
 {
   int ret = OB_SUCCESS;
-#ifdef ERRSIM
-  // test if this function can handle participants size overflow successfully
-  if (OB_FAIL(E(EventTable::EN_PARTICIPANTS_SIZE_OVERFLOW) OB_SUCCESS)) {
-    OB_MAX_TRANS_SERIALIZE_SIZE = 1500;
-    OB_MIN_REDO_LOG_SERIALIZE_SIZE = 500;
-    TRANS_LOG(INFO, "ERRSIM modify trans ctx serialize size for case 1 ",
-              K(OB_MAX_TRANS_SERIALIZE_SIZE), K(OB_MIN_REDO_LOG_SERIALIZE_SIZE));
-  } else if (OB_FAIL(E(EventTable::EN_PART_PLUS_UNDO_OVERFLOW) OB_SUCCESS)) {
-    OB_MAX_TRANS_SERIALIZE_SIZE = 7500;
-    OB_MIN_REDO_LOG_SERIALIZE_SIZE = 500;
-    TRANS_LOG(INFO, "ERRSIM modify trans ctx serialize size for case 2 ",
-              K(OB_MAX_TRANS_SERIALIZE_SIZE), K(OB_MIN_REDO_LOG_SERIALIZE_SIZE));
-  }
-
-  OB_MAX_UNDO_ACTION_SERIALIZE_SIZE = OB_MAX_TRANS_SERIALIZE_SIZE - OB_MIN_REDO_LOG_SERIALIZE_SIZE;
-
-  ret = OB_SUCCESS;
-#endif
+
+  INJECT_PARTICIPANTS_OVERFLOW_ERRSIM
 
   int64_t participants_size = participants_.get_serialize_size();
   if (participants_size > OB_MAX_TRANS_SERIALIZE_SIZE) {
     ret = OB_SIZE_OVERFLOW;
-    TRANS_LOG(WARN, "Participants are too large which may make dump trans state table failed.",
-              KR(ret), K(participants_size), K(participants_.count()),
-              K(OB_MAX_TRANS_SERIALIZE_SIZE), K(participants_));
+    TRANS_LOG(WARN,
+        "Participants are too large which may make dump trans state table failed.",
+        KR(ret),
+        K(participants_size),
+        K(participants_.count()),
+        K(OB_MAX_TRANS_SERIALIZE_SIZE),
+        K(participants_));
   }
   return ret;
 }

src/storage/transaction/ob_trans_define.h

@@ -76,10 +76,17 @@ static int64_t OB_MIN_REDO_LOG_SERIALIZE_SIZE = 131072;
 static int64_t OB_MAX_TRANS_SERIALIZE_SIZE = common::OB_MAX_VARCHAR_LENGTH - 10 * 1024;
 
 // The participants and undo actions share the last storage space
-static int64_t OB_MAX_UNDO_ACTION_SERIALIZE_SIZE
-  = OB_MAX_TRANS_SERIALIZE_SIZE - OB_MIN_REDO_LOG_SERIALIZE_SIZE;
+static int64_t OB_MAX_UNDO_ACTION_SERIALIZE_SIZE = OB_MAX_TRANS_SERIALIZE_SIZE - OB_MIN_REDO_LOG_SERIALIZE_SIZE;
 
-class ObTransErrsim {
+struct UnuseUndoSerializeSize {
+  UnuseUndoSerializeSize()
+  {
+    UNUSED(OB_MAX_UNDO_ACTION_SERIALIZE_SIZE);
+  }
+};
+
+class ObTransErrsim
+{
 public:
   static inline bool is_memory_errsim()
   {

src/storage/transaction/ob_trans_part_ctx.h

@@ -405,8 +405,7 @@ public:
       K(mt_ctx_.get_checksum_log_ts()), K_(is_changing_leader), K_(has_trans_state_log),
       K_(is_trans_state_sync_finished), K_(status), K_(same_leader_batch_partitions_count), K_(is_hazardous_ctx),
       K(mt_ctx_.get_callback_count()), K_(in_xa_prepare_state), K_(is_listener), K_(last_replayed_redo_log_id),
-      K_(status), K_(is_xa_trans_prepared), K_(redo_log_id_serialize_size), K_(participants_serialize_size),
-      K_(undo_serialize_size));
+      K_(status), K_(is_xa_trans_prepared));
 
 public:
   static const int64_t OP_LOCAL_NUM = 16;
@@ -615,8 +614,8 @@ private:
   bool is_xa_last_empty_redo_log_() const;
   int fake_kill_(const int64_t terminate_log_ts);
   int kill_v2_(const int64_t terminate_log_ts);
-  int calc_serialize_size_and_set_redo_log_(const int64_t log_id);
   int calc_serialize_size_and_set_participants_(const ObPartitionArray &participants);
+  int do_calc_and_set_participants_(const ObPartitionArray &participants);
   int calc_serialize_size_and_set_undo_(const int64_t undo_to, const int64_t undo_from);
 
 private: