Jump to content
  • Advertisement

Asu

Member
  • Content Count

    11
  • Joined

  • Last visited

Community Reputation

0 Neutral

About Asu

  • Rank
    Member

Personal Information

  • Interests
    Art
    Programming

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. I did some quick&dirty tests a while ago wrt generic vs native on linux/clang/x86-64. I found out that the generic calling convention is noticeably faster when dealing with less parameters, but slows down as you add more parameters and return data. This was a synthetic test, the actual overhead is probably much less important when the VM actually does more useful work. When using blindmindstudio's JIT (which unfortunately for you does not support ARM64 and likely never will), native calls become much faster than generic calls as native calls usually bypass AS' system function calling.
  2. Asu

    Building scripts in multiple-threads.

    I would expect the overhead of saving and loading bytecode to be relatively low, but I could be wrong (this is not my code base, after all 😄). Yes, but only using a much older version of AngelScript (2010-era). It unfortunately did not work well. I do not remember the details, but I remember dealing with problems related to shared classes and other crashes. I have seen from the changelog that there were a lot of fixes and changes related to bytecode saving/loading, but I have not tried on newer versions. I could try again, but not so easily, because a lot of code has changed between my initial implementation for bytecode caching and the head of my branch for the game. In the end I am not sure that I would want to deal with loading/saving bytecode (especially from the disk or from the network) for the already okay loading times - 6s for the entire game to start and load a local game on a T9600, without LTO. I believe it also compile scripts that are not in use by the gamemode. I have not really formally verified the results, but loading times of the entire game (in the same scenario as above but on an i5-4670K@4.4GHz) are reduced from 3s to 2.3s on average. In my testing, basically all of that time is script compilation. Interestingly enough, the rest of the game does not benefit nearly as much from it.
  3. Asu

    Building scripts in multiple-threads.

    I was actually looking for info about this today. My only interest into this was to cut down loading times. One way I was thinking I could implement this (in the game engine) is by spawning multiple engines in parallel, registering the interface for each of those, feed them scripts and copy bytecode to the main thread. That being said compile times in AS were vastly improved "recently" (possibly several years ago), so I don't think I'm willing to bother implementing it to shove off an extra few percents. Interestingly enough, enabling LTO results in a big performance increase for compilation times (25%+).
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!