Thanks for the info James.
I do not use Advanced Lighting, but I very much experience the odd frame drop from time to time. After a number of tests performed over the years, I have found that performing the standard sync call in a loop does not yield the best performance.
This may be irrelavent for advanced lighting, since it is not a system I am fully familiar with; although I use some of Evolves other assets and tools.
The following paradigm can be proven valid if you take a look at the AL update functions; which may help you find the cause. AL does not run that fast on my machine either; it looks good though
Firstly, the standard approach of calling sync in an unconstrained continuous loop will run an update on all of the entities and processes within the DBP engine, including calls to update windows events, object interactions, render sorting, limb frustrum culling; the lot. That
may not be what you want to be performing all of the time, which I will now explain.
Depending on the type of game, you may not need to call the full sync hardly ever, or perhaps just a few times per second, it may be better to
call FastSync most of the time, which will only focus on the rendering I believe.
If none of the shaders in use or the shaders visible from the camera feature animation, you can get away with just one call to sync or fastsync, then hold the frame; at least until something moves. This has the potential to free 99% of your processing resources for game mechanics; so if it is viable to organize your entities to determine which ones require the sync and which ones do not, while the player and all objects in the view are stationary, you can provide the max FPS. Nothing special for certain games, but for others which perform continuous calculations for AI or object loading, this is a plus.
Now, for when things are in motion and your game permits, you may only need to draw such moving elements 20 to 60 times per second with Sync or FastSync; and you can do that without hindering the playing experience by performing non rendering updates as many times as you like, so as long as you only draw things as often as they need to be drawn. Using a multicore physics systems like PhysX and the Dark AI multicore system is a good idea, this means the game mechanics can be handled with the DBP App's CPU focusing on running AL.
So in the case of my game, I only call sync/fastsync when it is necessary. You can still query the moving objects and perform collisions without sync calls, thus process game mechanics.
Finally, a few calls to Nice Sleep (Matrix1) or the Windows API sleep (Not the vanilla DBP sleep) can cool down the CPU and free it for the operating systems own rendering of your game window and its event system. You can call the sleep command perhaps 1 to 10 times per second depending on the type of game; calling sleep every loop will likely slow things down too much.
The point of this paradigm is that the best frame rate possible is that which calls Sync/FastSync less often. This also makes the use of the Screen FPS command as a performance tool redundant, since that is simply the amount of screen renderings per second, not the amount of
update frames per second. If tweaking the pipeline, you'd have to make your own FPS calculation based on the amount of game loops, not the amount of sync calls.
That's my two cents.