Fast Math

Noise-related code now specifically enables the GCC "fast-math" optimizations.  Strict IEEE conformance is not necessary (or even really relevant) for noise-related calculations as far as I am aware, and NaN/infinities shouldn't happen.

This has been observed to provide a significant performance boost during column generation (and therefore noise manipulations).
Time Update

Fixed a few issues with the TimeModule class:

1. The code that calculated time remaining until the next tick didn't make a lot of sense, so it has been rewritten.

2. When instructed not to tick while there are no players online, the server was still reporting when ticks took too long, despite the fact that the ticks didn't do anything.  This has been corrected.
TimeModule to Singleton/Factory Pattern

The TimeModule class is now the Time class and is managed as a singleton through the factory pattern.

This involved renaming its Get member method to GetInfo and updating the DisplayModule class (which relied on the TimeModule class heavily).
Time Vanilla Interoperability

Updated the Time class to correct an issue with vanilla Minecraft interoperability:

A Minecraft world begins at 0 ticks (both in age and in time), which translates to 6AM rather than 12AM (as I had previously believed).

Therefore, the client and server were out of sync -- when the client thought it was 6AM, the server thought it was midnight.

This has been corrected by simply adding 6000 to the time ticks before using the value, which translates them between the vanilla Minecraft reality, and a more mathematically convenient model.
Server Factory

Added a static Get method to the Server class, which enables it to be used (by new code) as though it were managed by the singleton-/factory-model used by newer modules/classes.

This is a band-aid to allow both means of access until the code base can be refactored to use exclusively the new model.
Thread Pool Fix

Fixed an issue which was causing scheduled tasks to be inconsistently executed (sometimes they would be delayed for a much longer period of time than intended before being executed).
Thread Pool Fix

Fixed an issue which would cause thread pool workers' cleanup callbacks to be invoked twice under exceptional circumstances.
Thread Pool API Extension

The thread pool may now be queried to determine how many workers it is managing.

This will assist in managing/limiting concurrent tasks so as not to saturate the thread pool.
Synchronous Logging

Since MySQLDataProvider now logs asynchronously internally, the Server class' WriteLog and WriteChatLog functions no longer perform asynchronous logging -- they dispatch log requests to the data provider synchronously.

This accomplishes two things:

1. It allows data providers to implement asynchronous logging without layering asynchronicity ontop of asynchronicity (asynchronous Server::WriteLog in turn calling an asynchronous DataProvider::WriteLog -- a fair amount of overhead managing/dispatching an unnecessary asynchronous task).

2. Allows data providers to ensure in order logging.  Previously it was not uncommon for log entries to be logged out of the order in which they were dispatched due to the vagaries of threading.
Concurrency Manager

Added a class to mcpp.dll which allows thread pools to be managed in a much finer way than simply throwing tasks at them and waiting on the results.

The ConcurrencyManager class takes a number when it is constructed and wraps a thread pool.  Tasks may then be dispatched through the manager.  The manager will ensure that no more than the specified maximum number of tasks that it manages are in the thread pool at any one time.

This allows code that performs a large number of long-running tasks to conveniently enqueue them without saturating the thread pool and starving other tasks.