USTRUCT always copied by UFUNCTION if called by Blueprint

Development Platform & Builds
, ,
1

Hi everyone,

I noticed a performance issue caused by blueprints while working with big structures.

In particular, calling a UFUNCTION that accepts a USTRUCT as an input parameter creates a copy of the structure before using it.

This behavior is present in Blueprint, but is absent when calling the function from code.

This is a snippet (with a small structure) used to reproduce the issue:

`#pragma once

include “CoreMinimal.h”
include “Kismet/BlueprintFunctionLibrary.h”
include “ExampleBlueprintFunctionLibrary.generated.h”

USTRUCT(BlueprintType)
struct FExampleStruct
{
GENERATED_BODY()

UPROPERTY(EditAnywhere, BlueprintReadWrite)
int32 ExampleValue = 0;

FExampleStruct()
{
UE_LOG(LogTemp, Log, TEXT(“%s”), StringCast(FUNCTION).Get());
}

FExampleStruct(const FExampleStruct& Other)
: ExampleValue(Other.ExampleValue)
{
UE_LOG(LogTemp, Log, TEXT(“%s”), StringCast(FUNCTION).Get());
}

FExampleStruct(FExampleStruct&& Other)
: ExampleValue(Other.ExampleValue)
{
UE_LOG(LogTemp, Log, TEXT(“%s”), StringCast(FUNCTION).Get());
}

FExampleStruct& operator=(const FExampleStruct& Other)
{
UE_LOG(LogTemp, Log, TEXT(“%s”), StringCast(FUNCTION).Get());

if (this == &Other)
return *this;
ExampleValue = Other.ExampleValue;
return *this;
}

FExampleStruct& operator=(FExampleStruct&& Other)
{
UE_LOG(LogTemp, Log, TEXT(“%s”), StringCast(FUNCTION).Get());

if (this == &Other)
return *this;
ExampleValue = Other.ExampleValue;
return *this;
}
};

UCLASS()
class EXAMPLERUNTIME_API UExampleBlueprintFunctionLibrary : public UBlueprintFunctionLibrary
{
GENERATED_BODY()

UFUNCTION(BlueprintCallable)
static int32 GetExampleValue(const FExampleStruct& InStruct)
{
UE_LOG(LogTemp, Log, TEXT(“%s”), StringCast(FUNCTION).Get());
return InStruct.ExampleValue;
}

UFUNCTION(BlueprintCallable)
static void SetExampleValue(UPARAM(Ref) FExampleStruct& InStruct, const int32 InValue)
{
UE_LOG(LogTemp, Log, TEXT(“%s”), StringCast(FUNCTION).Get());
InStruct.ExampleValue = InValue;
}
};`

This is the Blueprint calls to reproduce the issue:

[Image Removed]

And this is the OutputLog that shows the behaviour:

LogBlueprintUserMessages: [ExampleActor_C_1] BP Pre SetExampleValue - 0 LogTemp: FExampleStruct::FExampleStruct LogTemp: FExampleStruct::operator = LogTemp: UExampleBlueprintFunctionLibrary::SetExampleValue LogBlueprintUserMessages: [ExampleActor_C_1] BP Post SetExampleValue - 1 LogBlueprintUserMessages: [ExampleActor_C_1] BP Pre GetExampleValue - 1 LogTemp: FExampleStruct::FExampleStruct LogTemp: FExampleStruct::operator = LogTemp: UExampleBlueprintFunctionLibrary::GetExampleValue LogBlueprintUserMessages: [ExampleActor_C_1] BP Post GetExampleValue - 1

Is this the intended behaviour of structs (to be always copied when a UFUNCTION is called from Blueprints)?

This is causing performance issues in our projects.

Thank you in advance,

Lorenzo

2

Hi Lorenzo,

That’s interesting, I was also under the impression that structs passed by reference wouldn’t be copied. I’m looking into it now and should get back to you soon.

Best regards,

Vitor

3

Hi Lorenzo,

After diving into the engine source code for a bit, I came to the conclusion that this behavior is indeed by design. Unreal treats USTRUCTs as value types for the most part, so passing them by reference should be considered more of a convenience rather than an optimization. The copy comes from the following code, which runs on the beginning of a UFUNCTION called from blueprints, for each struct passed by reference:

#define PARAM_PASSED_BY_REF(ParamName, PropertyType, ParamType) \ ParamType ParamName##Temp; \ ParamType& ParamName = Stack.StepCompiledInRef<PropertyType, ParamType>(&ParamName##Temp);The workaround here would be to either use a UObject instead of a struct, or to wrap your large struct inside a UObject. In recent UE versions, you can also try to use FInstancedStruct, although that offers much more than you probably need.

Having said all that, there is one thing that got me curious. The code I showed above creates a temporary structure, which makes it look like that would be the actual target of the reference passed into the native function (later requiring a copy back into the actual structure). However, this is not what happens, at least in recent UE versions. I added some code to your repro that prints the addresses of the structures being used, and I could see that, in the end, the actual struct, not the temporary one, is passed into the native function. So, this temporary copy does not really seem necessary. It could be required by some deeper machinery of the blueprint VM that I am not aware, though. I’ll try to ask around and see if anyone from Epic can shed more light on this. But in any case, the recommendation for you at this time would be to use one of the approaches I mentioned above to work around this.

Best regards,

Vitor

4

Hi Vitor,

Thank you for the research and the workarounds.

In this case, we moved the implementation to the C++ code to avoid bigger refactors, but in the future, we will avoid using large USTRUCTs in Blueprints.

Keep me up to date on Epic answer.

Best regards,

Lorenzo