ExecutionEngineException when serialising derived class on mobile

Hi there!

I encounter the following error on mobile when serializing a derived class. This only seems to happen on mobile (iOS, haven’t tested Android yet), and works fine on other platforms:

ExecutionEngineException: Attempting to call method 'DanielLochner.Assets.CreatureCreator.AttachedLimb::Serialize<Unity.Netcode.BufferSerializerWriter>' for which no ahead of time (AOT) code was generated.  Consider increasing the --generic-virtual-method-iterations=1 argument

Here is a link to the script: https://github.com/daniellochner/creature-creator-game/blob/main/Assets/CreatureCreator/Scripts/Runtime/Data/AttachedBodyParts/AttachedLimb.cs

[daniellochner]

Hi there. I was able to fix the issue by navigating to Build Settings > IL2CPP Code Generation and selecting Faster (smaller) builds instead of Faster runtime.

However according to this forum post, it seems it may affect runtime performance?

[ShadauxCat]

Hi Daniel,

I’m sorry this took me so long to get to, but I was finally able to reproduce it. This isn’t something we can easily fix within the 1.x line because it would require breaking changes, but I WAS able to identify a workaround.

It seems that calling a virtual method from an interface method throws off the IL2CPP compiler, but if you make the interface method itself virtual, it works. So instead of what you’re doing currently:

class BaseClass: INetworkSerializable
{
  public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
  {
      Serialize(serializer);
  }

  public virtual void Serialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
  {
      // code
  }
}

class ChildClass: BaseClass
{
  public override void Serialize<T>(BufferSerializer<T> serializer)
  {
      base.Serialize(serializer);
      // code
  }
}

You can instead write it like this:

class BaseClass: INetworkSerializable
{
  public virtual void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
  {
      // code
  }
}

class ChildClass: BaseClass
{
  public override void NetworkSerialize<T>(BufferSerializer<T> serializer)
  {
      base.NetworkSerialize(serializer);
      // code
  }
}

And the IL2CPP compiler is able to generate all the needed AOT implementations for both of those methods.

If you want, you can still use other methods to help with serialization - just make them private and call from with NetworkSerialize(). For example:

class BaseClass: INetworkSerializable
{
  public virtual void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
  {
      Serialize(serializer);
  }

  private void Serialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
  {
      // code
  }
}

class ChildClass: BaseClass
{
  public override void NetworkSerialize<T>(BufferSerializer<T> serializer)
  {
      base.NetworkSerialize(serializer);
      Serialize(serializer);
   }
   
  private void Serialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
  {
      // code
  }
}

The IL2CPP compiler does manage to generate correct AOT code for non-virtual methods that are called from within NetworkSerialize, but seems to choke on generating override methods that are called from the parent class’s NetworkSerialize.

I hope that helps!