Sign in to follow this  
petya-kurochkin

hot swap / live reload

Recommended Posts

Hi!  

Sorry for opinion-based question, but I'm a newbie in C++ so I'm not able to make decisions on my own yet :-) 

 

 

Today I've done a proof of concept of live reload C++ code that could be okay for level editors / scripts and so on. I think there're a lot of people who also use such mechanism in their game editors.

What do you think about it? How do you keep the save of app when it changes? What problems does it have? Is it better for you than lua/python/js?

I see the next advantages:

  1. After I've done with experiments, I can just include source code to my project and compile it statically.
  2. I can use all low-level API that, usually, is not available in scripting languages.
  3. Should work fast (but I haven't measured yet).
  4. Full-featured IDE is available (in Python I have some problems with autocomplete, JS also doesn't know about types/etc, for your own script you I also need my own IDE :-) ).

Disadvantages (?):

  1. I'm not sure that it's fast yet (virtual functions, dynamic linking).
  2. I'm not sure it's stable yet. Perhaps, between reloading it'll give me some kind of segfault. But not in my hello worlds it's still stable :-/
  3. Perhaps, C++ is not good at scripting? :-/
Edited by petya-kurochkin

Share this post


Link to post
Share on other sites
It should work fine as long as you handle every low-level nuance of compiled code and data that you are going to use.

Allocated objects from version N may need their vtable pointers patched when version N+1 code is loaded.

Allocated objects for types that had their binary layout change need to be remapped.

Any function pointers or pointers to static data that you're reloading need to be patched.

You might decide that it's easier to serialize all dynamically allocated data when unloading version N and deserialize it after version N+1 loads. It might be hard to make sure you don't have lingering references anywhere. Edited by Nypyren

Share this post


Link to post
Share on other sites
The advantages of hot-swapping code tend to increase dramatically with team size.

In other words, if it's just you, you might get some small wins from it, but you'll probably drain a ton of time into the kinds of bit-twiddling issues that Nypyren listed.

If it's a lot of people (read: at least 5) and they're all better C++ programmers than they are at [some scripting language X], then this can be a big win, because you don't have to lose your mental model of how the language works while iterating.

In any case it's a cool tech demo to have in your back pocket and I think it leads to learning a lot about how C++ is implemented in the real world, which is valuable knowledge. Just be careful not to fall into the trap of spending more time on your reloading infrastructure than you do on your game :-)

Share this post


Link to post
Share on other sites

I've had hotloading code in my game for some time now, it comes in the form of a reloadable dll where I recompile and reload code. Here's some best practices that I recommend.

- Avoid having to fiddle with vtables (that means not having your class hierarchies inherit across the reload dll). Instead, pass in a vector of structs which contain functions and values to be reloaded. The highly probable cause of most crashes resulting from this reloading code is using old function addresses that not longer exist on the dll since it was reloaded, weren't wiped on the executable.

- Start with a small sub-system in your game first. Particle systems are one of those; try tweaking and live reloading some particle movements. It's a different experience compared to tweaking knobs/sliders on a GUI.

Share this post


Link to post
Share on other sites
Is it better for you than lua/python/js?

C++ as a scripting environment for gameplay, over [everything else]? Never. I really like low-level coding in C++, and far prefer it to ie. C#, but for coding gameplay, its too verbose to me, even with C++1X, and requires you to do too much "unnecessary" shit to be worth it (.h/.cpp-splits ie). Moreever, you'd probably need a good editor binding for your C++-code to be worth a damn as a replacement for regular scripting - think in terms of Unreal, where you can mark variables of your C++-classes to be editable in the editor, etc... . And thats probably much more trivial with "common" "scripting languages" like lua, which support reflection.

TBH, I personally even prefer visual scripting far over regular scripting/coding these days anyway (my current projects gameplay-code is 100% "Blueprints"), so I'd never ever go to C++ for that. Just my 2 cents, might be just personal preference for all its worth.

Edited by Juliean

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this