You're likely already aware of this, but I've been crashing on the barbarian turn for the first turn with the experimental build. Occasionally I'll get to turn 2 before the crash. No idea how to analyze it, but assume you're just working on it.
Yeah, that was caused by a typo, I fixed it in a commit pushed a few minutes after the initial slew. I'm currently tracking down an infinite loop which may or may not be present with the latest commits.
For future reference, if you compile with a debug flag, it'll generate a .pgd (debug database). If you include the .pgd in the mod (with VFS) and attach the Civ5 process to VS, you'll be able to troubleshoot crashes and/or infinite loops: for the former, VS will direct you to the line that caused the crash as well as the call stack (useful for patching overlooked null pointer deference possibilities), while for the latter, you can just pause the Civ5 process whenever you think the game thread has entered an infinite loop (or force a minidump), at which point you can see which loop is causing the problem after you browse to the game thread (it'll either be the loop enclosing the currently executed line or a loop enclosing a function in the call stack).
If VS doesn't like your machine (neither 2008 nor 2013 like mine), you can also use the Windows Debugging Toolkit to look at minidumps; I prefer the debugging toolkit to VS because I have a lot more control over what source files and what debugging symbols I load up, whereas VS doesn't give me any control.
Do note that when you're running a version of the DLL with optimizations turned on, the currently executing line that VS or the debugger displays may not necessarily be correct; you'll notice this especially when the problematic code is located in an inlined function (the debugger will point to the inlined function's call instead of the problematic code within the inlined function). The only way to work around this is to compile a DLL with all optimizations turned off.
Running v9 and it's VERY slow late game - over 5 minutes per turn. It's a pangea plus map normal size/epic speed. It takes a long time on City-States (there are 8) and on some civs which only have 1 city left. Not usable at this point give the speed.
It's kind of unavoidable, unfortunately, and it might get worse in v10. The slowness is caused by the AI using the pathfinder (the bit of the game that calculates the best movement path from a tile to another tile) a lot more than it did in the unmodded game, and the pathfinder is kind of a mess code-wise: it works, but that's pretty much the only good thing I can say about it (bad things include: it's single-threaded, it has a lot of redundant checks and calls pre-v10, it has room for caching certain data values then doesn't cache those values pre-v10). Ironically, the feature that is most likely responsible for the unenjoyable slowdown is the one that is probably the biggest AI improvement in v9: move-and-shoot, accurate move-and-shoot as well (the one in Ninakoru's Smart AI might run a bit faster, but only because it's ignored for siege units and units with range 1). When AIs go to war, they need to calculate where all of the enemy ranged units can move-and-shoot (as well as their own), and each AI player runs their own calculations, including city-states: this means that if an AI player with 2 CS allies goes to war with another AI with 3 CS allies, 7 AI players end up performing move-and-shoot calculations from that single war alone. As the game progresses, the AI creates more and more (ranged) units, so more and more move-and-shoot calculations need to be run, causing those really slow turns.
The only way to really "fix" the issue in v9 is to play on smaller maps, on a lower difficulty, and/or with less AIs: smaller maps cut down on possible tiles to move-and-shoot from as well as on AI units, lower difficulties cut down on AI units and warlike AI behavior, and less AIs cut down on the amount of AI players that run almost-redundant move-and-shoot calculations (eg. if 3 AI players are warring the same fourth player, all 3 need to perform the same move-and-shoot calculations for every one of that fourth player's ranged units).
I'm introducing a lot of optimizations in v10 that should help issues surrounding move-and-shoot's slowdowns, so that's good. However, I'm also repurposing DangerPlots (the system that the AI uses to keep track of what tiles are dangerous to be in) from a vague, add-up-attacking-unit-strengths thing into a full-blown damage preview system (ie. the AI will know precisely how much damage a unit could take if it is kept in a tile): while this is definitely good for AI accuracy, especially where unit placement is concerned, replacing a single integer call with at least 200-odd, intricate calculations causes noticeable turn slowdowns even in the earlygame.
Once I get the system to work properly (it works about 99% of the time, and I want it to work 99.9999% of the time), I'll try to optimize it as much as possible to see if I can cut down on expensive function calls; right now, I don't even know which function calls are the more expensive ones.