[C#] Asynchronous processing and async/await

A great overview of how async/await works, from the differences between async and multithreading programming to explaining how async is compiled and operates under the hood. It's an excellent resource for interview preparation.

The content is in Japanese, but it's by the already legendary Annulus Games, and auto-translation does a good job.

https://annulusgames.com/blog/async-await/

#async #interview

Instantly Boost Unity Game Performance With IL2CPP_USE_SPARSEHASH

Finally, another post on my blog. This investigation was time-consuming, and while I won't say I enjoy digging through generated C++ code, the results were worth the effort. Hit the fire emoji if you like this type of content and want me to write more of it.

The metadata in IL2CPP generated for each type and used for tasks like virtual method invocation is barely covered online. Not even the Unity documentation provides sufficient information. More crucially, you won't find details online about how the metadata is stored in memory or the existence of the define IL2CPP_USE_SPARSEHASH. In this post, I dive into the internals available in the generated C++ code to learn more about it and how we can significantly boost the performance of some operations in our games using this knowledge.

Here is a lifehack to improve performance using a concrete example of dependency resolution at the app start for all DI enjoyers. Of course, this isn't free, but performance is always about compromise.

https://gamedev.center/instantly-boost-unity-game-performance-with-il2cpp_use_sparsehash/

I've also posted this on Reddit, so I would appreciate it if you upvote it for all the effort put into this: a reddit post

#il2cpp #performance #optimization #IL2CPP_USE_SPARSEHASH

ECS Galaxy Sample: a project showing a large-scale simulation of several teams of spaceships fighting for the control of planets. This is a fully-automated simulation, but players can spectate using different camera modes. Players can also bring up a "Settings" menu during play to tweak some simulation parameters in realtime.

This sample aims to strike a balance between being simple and lightweight enough to be easy to learn from, and involving enough non-trivial ECS game code (AI, spatial queries, event-based logic, different unit/building types and roles, etc...) to make an interesting showcase.

https://github.com/Unity-Technologies/ECSGalaxySample

#ecs #dots #sample

Chunk's Change Version

A detailed post on how .WithChangeFilter<T>() works in Entities

Then, there is a per-chunk number called ✏️ change version. How the chunk is considered "changed" in order to update this number is rather crude : Instantly when a query is executed related to that component and it has write permission. Then, chunks returned for that query will all get their ✏️ change version updated

It does not check whether system actually "change" the component's value with its work using the query. It just see the write dependency and thought the system "probably" changed that for all the matched chunks.

It is per chunk. There are other entities in the chunk that are not actually changed and still get iterated. Your logic must not be destructive to these entities. Try treating changed filter as optimization rather than branching logic, always imagine if the changed filter is removed, everything must still work like before but with worse performance

https://gametorrahod.com/change-version/

#dots #ecs

List Add is way slower (almost 3 times) in net9.0 preview 3 than with net8.0
dotnet/runtime

This is an interesting discussion and investigation into why performance significantly drops on one of the platforms after optimization in net9.0. I always love reading how engineers solve complex problems. It's fascinating to see what changes under the hood can cause such big differences in performance and how they track down the issue.

https://github.com/dotnet/runtime/issues/101437

#performance

10 Unity Audio Optimisation Tips

There are a few posts covering audio optimization available. While it's true that this topic is usually overlooked since assets, noscripts, and rendering optimizations yield more significant performance gains, it's great to have such posts bookmarked, as they list a lot of high-quality tips. Moreover, now you know that sounds might also cripple performance.

https://gamedevbeginner.com/unity-audio-optimisation-tips/

#audio #optimization

Unity Shader Variants Optimisation and Troubleshooting

When using shaders from the asset store it might become challenging to control shader variants leading to increased build size and time to prewarm it. It's a good post to bookmark and get back to it during your project check ups.

https://dev.to/attiliohimeki/unity-shader-variants-optimisation-and-troubleshooting-28ci

#optimization #shader #shadervariants

CPU performance optimization guide - part 1 - CPU performance optimization guide

A great example of how to profile CPU performance at the lowest level. From my experience, you very rarely need to dive this deep in your daily work. However, if a method is on the hot path and invoked many times per frame, and all low-hanging fruit optimizations are done, then you definitely need this post bookmarked for future reference

https://gpuopen.com/learn/cpu-performance-guide/cpu-performance-guide-part1/

#profiling #cpu

Introducing our new e-book: Unity’s Data-Oriented Technology Stack (DOTS) for advanced developers

Here's an overview of DOTS. Many people think DOTS is just ECS, but there are multiple packages and tools under this umbrella.

Of course, ECS is a big part of DOTS, which is why half of the book is about it, but you might be using DOTS without even knowing it, as some packages are jobified, and use burst/native collections under the hood.

https://blog.unity.com/engine-platform/new-ebook-understanding-unity-dots

#dots #book

ECS Programming Patterns from Official Packages

A list of advice how to perform common operations in unity.entities with examples from the entities package internals.
I also have personal notes with tips from the Hot Path Show that I found interesting, and they are pretty similar to what is shared in that post, e.g. tricks how to create new entities with the set of components without allocating a managed array of types and without adding components one by one which is very inefficient in the archetypes ECS implementation. This show is usually around 2 hours so it takes time to gather all these tips and sit through the whole video, so not everyone watches it completely. Put a 💯 reaction if you'd like me to publish it in a similar form to the post with top tips from Unite.

https://gametorrahod.com/ecs-patterns/

#dots #ecs

.NET 9: Array vs Dictionary lookup performance in C#

I wanted to revisit my old post about the performance of lookup operations in dictionaries and arrays to see how all the performance improvements in newer .NET versions affect old benchmarks. TL;DR: The benchmark shows that dictionary lookups are around 2 times faster in .NET 9 compared to Framework 4.8. This means there is now less sense to use arrays to speed up lookups in small collections.

This does not apply to Unity yet, though they promise CoreCLR integration, so it might become useful someday

https://gamedev.center/net-9-array-vs-dictionary-lookup-performance-in-c/

#performance #lookup

When Your Game Is Bad But Your Optimisation Is Genius

3 simple optimisations that you can use to make your game run up to 10 times quicker.
Not a Unity video, but still can be easily applied to a Unity game. I have done similar optimizations to the terrain a long time ago in my own mobile game and got a significant boost.

https://www.youtube.com/watch?v=5zlfJW2VGLM

Repo: https://github.com/vercidium-patreon/glvertexid

#optimisation #terrain

Unity 2D Radiance Cascade Demo

This repository provides a basic implementation of a global illumination technique based on the concept of Radiance Cascades, as described in the paper Radiance Cascades: A Novel Approach to Calculating Global Illumination.

The illumination algorithm is applied as a post-processing effect on the main camera.

The repository includes two versions of the algorithm:
3D Texture Implementation: For easy understanding of the technique.
2D Texture Implementation: For greater portability across different platforms.

I have tested it with different resolutions, and the highest one has put my high-end GPU to work taking 22 ms per frame. Would be interesting to check it in a real project and play around with values to find an optimal compromise.

https://github.com/ZY4N/Unity-2D-Radiance-Cascade-Demo

#computeshader #raytracing #lighting

Parsing JSON Really Quickly: Lessons Learned

1. No branching
2. Don't process byte by byte, use SIMD
3. Avoid memory allocations
4. Measure the performance (CI performance tests)

How simdjson is made that parses gigabytes of JSON per second. There are also a few performance tricks related to parsing.
And there is a very interesting comment under the video:

43:37 "cause you're assuming that the person running your program is not switching the CPU under you". The audience might be laughing, but this actually is sometimes a case, even in consumer hardware. Non-US Samsung Galaxy S9 has a heterogenous CPU, with some cores supporting the atomic increment instruction LDADDAL and others not, and with Linux kernel modified by Samsung to report that all cores support that instruction. Your program would crash after being rescheduled to another core.

Which is even more true nowadays with a wider adoption of e-cores and p-cores in modern CPUs.

https://www.youtube.com/watch?v=wlvKAT7SZIQ

#performance

Exploring a New Approach to Realistic Lighting: Radiance Cascades

The video explaining the theory behind a novel lighting approach. I also shared an open source implementation in Unity a while ago.

https://www.youtube.com/watch?v=3so7xdZHKxw

#lighting #radiancecascades

A genshin-like post processing render feature, based on URP.

https://github.com/kaze-mio/UnityGenshinPostProcessing

#renderfeature #urp #postproccess

SanderMertens/ecs-faq: Frequently asked questions about Entity Component Systems

A good starting point to dive into ECS. There is a strong emphasis on the performance of ECS, and while it is mentioned, it is not stated clearly that ECS is not always about performance. Primarily, it is an architectural approach. With the right design — both in terms of framework and game design — it can significantly benefit performance, but this is not guaranteed by default.

https://github.com/SanderMertens/ecs-faq

#ecs

Which collection interface to use?

Tl;dr:

Use the most generic types possible for arguments,

Use the most specific types possible for return values

Adhere to the following guideline.

Use IEnumerable for arguments as the most generic type possible.

Use IReadOnlyList for return values as the most specific type possible.

IQueryable is a leaky abstraction because it requires you to know which LINQ expressions the ORM can understand.

IList and Array aren’t suitable because they are mutable.

Keep in mind that some implementations of IEnumerable are also leaky abstractions

https://enterprisecraftsmanship.com/posts/which-collection-interface-to-use/

#design #api

Choosing the right network model for your multiplayer game

A good starting point, with references for in-depth investigation, to help you choose the right network model for your game by going over the list of questions the author provides and high level denoscriptions

https://mas-bandwidth.com/choosing-the-right-network-model-for-your-multiplayer-game/

#netcode