optimize InternalArgs

Author: blueloveTH

src/lang/BindingsHooks.cpp

@@ -130,24 +130,24 @@ bool GDNativeClass_getunboundmethod(py_Ref self, py_Name name) {
 		std::pair<GDNativeClass, py_Name> pair = stack->operator[](last_idx);
 		stack->remove_at(last_idx);
 
-		InternalArguments args;
-
 		Variant r_ret;
 		GDExtensionCallError r_error;
 		StringName method = python_name_to_godot(pair.second);
 		if (pair.first.type == Variant::OBJECT) {
-			args.append(python_name_to_godot(pair.first.name));
-			args.append(method);
+			InternalArguments args(2 + argc - 1);
+			args.set(0, python_name_to_godot(pair.first.name));
+			args.set(1, method);
 			for (int i = 1; i < argc; i++) {
-				args.append(py_tovariant(&argv[i]));
+				args.set(i + 1, py_tovariant(&argv[i]));
 			}
 			ClassDBSingleton *singleton = ClassDBSingleton::get_singleton();
 			static GDExtensionMethodBindPtr _gde_method_bind = internal::gdextension_interface_classdb_get_method_bind(singleton->get_class_static()._native_ptr(), StringName("class_call_static")._native_ptr(), 3344196419);
 			CHECK_METHOD_BIND_RET(_gde_method_bind, (Variant()));
 			internal::gdextension_interface_object_method_bind_call(_gde_method_bind, singleton->_owner, args.ptr(), args.size(), &r_ret, &r_error);
 		} else {
+			InternalArguments args(argc - 1);
 			for (int i = 1; i < argc; i++) {
-				args.append(py_tovariant(&argv[i]));
+				args.set(i - 1, py_tovariant(&argv[i]));
 			}
 			godot::internal::gdextension_interface_variant_call_static(
 					(GDExtensionVariantType)pair.first.type, &method, args.ptr(), args.size(), &r_ret, &r_error);

src/lang/Common.hpp

@@ -46,28 +46,58 @@ struct PythonScriptReloadingContext {
 };
 
 struct InternalArguments {
-	Vector<Variant> _args;
-	Vector<GDExtensionConstVariantPtr> _pointers;
+	union {
+		struct {
+			Vector<Variant> _args;
+			Vector<GDExtensionConstVariantPtr> _pointers;
+		} dyn;
+
+		struct {
+			Variant _args[4];
+			GDExtensionConstVariantPtr _pointers[4];
+		} stc;
+	};
+
+	int length;
+
+	InternalArguments(int length) : length(length) {
+		if (length > 4) {
+			dyn._args.resize(length);
+			dyn._pointers.resize(length);
+			for (int i = 0; i < length; i++) {
+				dyn._pointers.write[i] = &dyn._args[i];
+			}
+		} else {
+			for (int i = 0; i < length; i++) {
+				stc._pointers[i] = &stc._args[i];
+			}
+		}
+	}
 
-	inline void reset() {
-		_args.clear();
-		_pointers.clear();
+	~InternalArguments() {
+		if (length > 4) {
+			using DynType = decltype(dyn);
+			dyn.~DynType();
+		} else {
+			using StcType = decltype(stc);
+			stc.~StcType();
+		}
 	}
 
-	inline void append(const Variant &v) {
-		_args.push_back(v);
+	inline void set(int index, const Variant &val) {
+		if (length > 4) {
+			dyn._args.write[index] = val;
+		} else {
+			stc._args[index] = val;
+		}
 	}
 
 	inline const GDExtensionConstVariantPtr *ptr() {
-		_pointers.resize(_args.size());
-		for (int i = 0; i < _args.size(); i++) {
-			_pointers.write[i] = &_args[i];
-		}
-		return _pointers.ptr();
+		return length > 4 ? dyn._pointers.ptr() : stc._pointers;
 	}
 
 	inline int size() const {
-		return (int)_args.size();
+		return length;
 	}
 };