The C++ framework for developing highly scalable, high performance servers on Windows platforms.

• Home
• What
• Why
• How
• Who
• Products
• Pricing
• Blog
• Contact

Search

Release Notes - IO Tools Library

You might also be interested in the release notes for the libraries that this one is built on:

• Admin
• C++ Tools (this was a separate library prior to version 6.0 at which point it was merged with the Win32 Tools Library
• Core Tools
• Win32 Tools

Version 7.4

• Remove support for Visual Studio 2015.
• Remove deprecated functionality.

Version 7.3

• Clearly identify any open source software used by the framework and make it easy to disable it or see the relevant license details.
• Preparations for making the code compile on other platforms.
• Added support for a new method of dynamic object leak tracking.
• Removed the need for WinsockWrapper.h any reference to this header should be removed.
• Removed seldom used and untested aspects of the library. Contact us if you relied on functionality that is no longer present in this release.
• Removed the embedded WSABUF structure from the JetByteTools::IO::IBuffer interface. This is only required when the I/O call is issued and does not need to exist after the function call returns and so does not need to be part of the buffer itself. This also removes the need for the SetupX methods that were previously called prior or executing I/O operations.
• Added JetByteTools::IO::IBuffer:MakeSpaceAtFrontIfPossible()
• Added JETBYTE_IO_DEPRECATE_BUFFER_USER_DATA which defaults to 0.
• Added JETBYTE_IO_DEPRECATE_SEQUENCED_BUFFER_COLLECTION which defaults to 0.
• Added JETBYTE_IO_DEPRECATE_BUFFER_CHAIN_CUSTOM_BUFFER_INDEX which defaults to 0.
• Added JetByteTools::IO::CBufferFacadeOnRawMemory
• Added JetByteTools::IO::TBufferPool
• Added JetByteTools::IO::CCustomPoolBufferAllocator
• Added JetByteTools::IO::IAssociateDeviceWithIOSubSystem
• Added JetByteTools::IO::IAllocateBuffers::AllocateBuffers and JetByteTools::IO::IAllocateBuffers::AllocateBuffersForBytes
• Added JetByteTools::IO::CBufferChain::CopyChainIntoBuffer and JetByteTools::IO::CBufferChain::CopyDataIntoChain

Version 7.2

• Removal of manual "#define include guards" now that all supported compilers support pragma once.
• Removal of out of date lint directives.
• Added support for Visual Studio 2022 Preview.

Version 7.1

• Preparations for making the code compile on other platforms.
• Switch to using JetByteTools::Core::CReferenceCount for reference counts.
• Switch to using Core Tools atomic types rather than Interlocked operations directly.
• Switch to using JetByteTools::Core::ErrorCodeToErrorMessage() rather than JetByteTools::Win32::GetLastErrorMessage()
• Switch to using Core Tooks crash dumps rather than Win32 mini dumps.
• Switch to using Core Tools lockable objects rather than Win32 critical sections.
• Using JetByteTools::Core::CThreadId.
• Moved user data from after the buffer memory space to before it to fix potential alignment issues in JetByteTools::IO:CBuffer.

Version 7.0

• Major changes due to preparations for multi-platform support. Addition of CoreTools library which contains all cross platform code that was previously in Win32Tools.

Version 6.9.5

• Added support for Visual Studio 2019 (16.5 - 16.9).
• Updated project files to make release build optimisations consistent.
• Rationalised precompiled header usage.
• Removed unrequired includes.
• Began to move towards removing JetByteTools\Win32Tools\Utils.h by splitting it into more functionally cohesive headers.
• Changes to avoid explicitly catching JetByteTools::Win32::CSEHException now that it derives from JetByteTools::Win32::CException.
• Added a move constructor to JetByteTools::IO::CBufferChainStoresNulls
• Added JetByteTools::IO::CFixedFileHeaderRotatingAsyncFileLog which is a rotating log that can have some lines designated as 'header lines' that are included at the start of every new log file that is created.
• Changes to everything that supports JetByteTools::Win32::ILogMessages to support the new methods for writing blocks of lines at once.
• Changes to JetByteTools::IO::CRotatingAsyncFileLog to support file rotation based on number of lines or number of bytes and to allow turning off the logging of thread id and/or timestamp.

Version 6.9.4

• Added support for Visual Studio 2019 (16.4).
• Added a debug log message to alert you to the fact that a JetByteTools::IO::CAsyncFileLog instance has had OnPendingWriteLimit() called. This can seriously affect performance and is likely something that you want to be informed of!

Version 6.9.3

• Fixed issued raised by Resharper++
• Changed include path separators from \ to / so as to support compilation on Linux using CLANG
• Fixed case of include file names to aid portability.
• Migrating code towards 'modern C++' idioms.
• Suppress warning C4355 "'this': used in base member initializer list" in Warnings.h and remove per file suppressions. We just use this idiom far too often for it to be a special case.
• Added support for Visual Studio 2019 (16.3).
• Dropped support for Visual Studio 2013.
• Removed code that was deprecated by JETBYTE_DEPRECATE_BUFFER_CHAIN_METHODS and JETBYTE_DEPRECATE_BUFFER_PROCESSOR_METHODS.

Version 6.9.2

• Added support for Visual Studio 2017 (15.6 - 15.9).
• Added support for Visual Studio 2019 (16 - 16.2).
• Bug fix to JetByteTools::IO::CBufferChainStoresNulls::Dump() so that we walk the buffer chain correctly.
• Bug fix to CUnsortedBufferProcessor::~CUnsortedBufferProcessor() where we were incorrectly releasing the m_pProcessingBuffer which is used as a 'marker' and for which we don't own a reference.
• Added JETBYTE_DISABLE_POOLING_BUFFER_ALLOCATOR which, when defined to 1 disables all pooling in buffer allocators.
• Added JetByteTools::IO::CBufferChainStoresNulls::Detach() and JetByteTools::IO::CBufferChainStoresNulls::Attach() which operate in the same way as in JetByteTools::IO::CBufferChain.
• Added JetByteTools::IO::CBufferChainStoresNulls::Swap()
• Removed const from some of the methods in JetByteTools::IO::IProvideWorkItems, JetByteTools::IO::IIOPool, JetByteTools::IO::IDispatchToWorkerThread, JetByteTools::IO::CIOPoolBase, JetByteTools::IO::CIOPool JetByteTools::IO::CIOPoolEx and JetByteTools::IO::IProvideWorkItems.
• Never track buffer references from buffer allocators created by JetByteTools::IO::CRotatingAsyncFileLog
• Bug fix to JetByteTools::IO::CSequencedBufferCollection::Purge() so that we reset the next buffer sequence correctly.

Version 6.9.1

• Added support for Visual Studio 2017 15.5.
• Added JetByteTools::IO::CBuffer::ReportOwnershipChange() so that reference tracking of buffers will report richer traces from smart pointers.
• Added code to prevent new items being posted to objects derived from JetByteTools::IO::CIOPoolBase after the pool has been shut down.

Version 6.9

• Fixed issued raised by CppDepend
• Fixed issued raised by Resharper++
• Removed JetByteTools::IO::CBufferList.
• Removed JetByteTools::IO::CInOrderBufferList.
• Removed JetByteTools::IO::CNonPooledBuffer.
• Removed JetByteTools::IO::CSequentialBufferList.
• Removed JetByteTools::IO::CSmartBufferList.
• Removed JetByteTools::IO::CLockFreeBuffer and JetByteTools::IO::CLockFreeBufferAllocator.
• Removed the concept of "Multi buffer handles" and JetByteTools::IO::IAllocateMultiBufferHandles, JetByteTools::IO::CMultiBufferHandle and JetByteTools::IO::CMultiBufferHandleAllocator.
• Added JetByteTools::IO::CBufferRingBuffer which is a ring buffer of a fixed size that can contain JetByteTools::IO::IBuffer instances.
• Added JetByteTools::IO::IHandler::GetError() which is used by JetByteTools::IO::CIOPoolEx to obtain per operation error codes from batches of completions retrieved from the underlying IOCP. This results in changes to the following classes: JetByteTools::IO::CAsyncFileReader, JetByteTools::IO::CAsyncFileWriter, JetByteTools::IO::CIOPoolBase, JetByteTools::IO::CIOPoolEx and JetByteTools::IO::CJobEventManager.
• Bug fix to JetByteTools::IO::CBuffer::DuplicateBuffer() so that it allocates a buffer of suitable size when a 'custom sized buffer' is being duplicated.
• Bug fix to JetByteTools::IO::CBufferAllocator::InternalAllocateCustomSizedBuffer() so that it correctly calls OnBufferAllocated() on the monitoring interface.
• Added code so that JetByteTools::IO::CBufferHandle::DuplicateBuffer() is permitted.
• Added JetByteTools::IO::IAllocateBuffer::AllocateCustomSizedBuffer().
• Added JetByteTools::IO::IPoolBuffers::AllocateCustomSizedBuffer().
• Added JetByteTools::IO::CBufferChain::DuplicateBufferChain() which duplicates a buffer chain using the buffer at the head of the source chain to provide new buffers for the duplicate chain. Note this differs from JetByteTools::IO::CBufferChain::CopyBufferChain() which uses buffer handles over the original buffers for the copy.
• Added JetByteTools::IO::CBufferChain::AddData() which will add the supplied data to the end of the chain and extend the chain if necessary using the last buffer in the existing chain to allocate the new buffer required.
• Added JetByteTools::IO::IIterateableBufferChain::TotalBytes().
• Breaking change JetByteTools::IO::IAllocateBuffer, JetByteTools::IO::IAllocateBufferHandles, JetByteTools::IO::IAllocateBuffers, JetByteTools::IO::IManageBufferHandleLifeCycle, JetByteTools::IO::IManageBufferLifeCycle, JetByteTools::IO::IPoolBuffers and JetByteTools::IO::IBuffer all changed to return JetByteTools::IO::CSmartBuffer rather than raw pointers.
• Breaking change Methods on JetByteTools::IO::IBufferChain and JetByteTools::IO::IUnsortedBufferChain that do not take JetByteTools::IO::CSmartBuffer have been deprecated. Some additional methods have also been removed where alternate functionality is available. Use DEPRECATE_BUFFER_CHAIN_METHODS to control if these methods are still available.
• Breaking change Methods on JetByteTools::IO::IBufferProcessor that do not take JetByteTools::IO::CSmartBuffer have been deprecated. Use DEPRECATE_BUFFER_PROCESSOR_METHODS to control if these methods are still available.
• Added JetByteTools::IO::IMonitorBufferAllocation::OnBufferAllocatedFromPool() and JetByteTools::IO::IMonitorBufferAllocation::OnBufferReleasedToPool() both of which default to calling the previous, non-pool, allocation monitoring functions.

Version 6.8

• Made pragma once unconditional in headers.
• Fixed issued raised by PC-Lint Plus.
• Fixed issued raised by CppDepend
• Fixed issued raised by Resharper++
• Use override rather than virtual for implementations of virtual functions in derived classes.
• JetByteTools::IO::CLockFreeBuffer and JetByteTools::IO::CLockFreeBufferAllocator have been deprecate and are no longer available unless you define JETBYTE_DEPRECATE_LOCK_FREE_BUFFERS to 0 in Config.h. If it's found that there is widespread use of these buffers then we will refactor them so that there is less duplicate code between them and the non-lock free version.
• JetByteTools::IO::CAsyncFileLog now pads its thread ids to 8 characters. This means that thread ids in logs now always take up the same amount of space.
• Bug fix to JetByteTools::IO::CAsyncFileWriter to do with how and when it notifies on the last write completion. This allows for setting the flag to notify multiple times through the lifetime of the object and makes the definition of 'last' a little clearer in these circumstances.
• Added a new debugging aid for JetByteTools::IO::CBuffer. If JETBYTE_CHECK_BUFFER_VALIDITY_ON_EVERY_ACCESS is defined to 1 then each access to a buffer causes a check for 'validity' (i.e. that the buffer is active and hasn't been released back to the allocator.
• Added move constructor and assignment operator to JetByteTools::IO::CCustomPoolSmartBuffer. This removes unneccessary reference counting activity.
• Added JetByteTools::IO::IDispatchToWorkerThread which JetByteTools::IO::IIOPool now inherits from. This interface provides a slightly different way to dispatch to the pool.
• Added JetByteTools::IO::IIterateableBufferChain::PeekTail() and JetByteTools::IO::IIterateableBufferChain::Detach() which is really just a case of hoisting some methods from JetByteTools::IO::CBufferChain's interface into its base class interface.
• Changed how JetByteTools::IO::CIOPool base calculates the number of threads required if 0 is passed in. Previously it was 2 * number of processors which worked fine back in the day but now it tends to create pools with too many threads. Now it caps this calculation at 4. If you're relying on passing <0> to get a large number of threads then you should specify the required amount explicitly.
• Added the ability to disable 'put back' into JetByteTools::IO::CSequencedBufferCollection.
• Added JetByteTools::IO::CSequencedBufferCollection::IsNext() which returns true if the supplied buffer will be immediately returned from the collection by a call to JetByteTools::IO::CSequencedBufferCollection::Next() that attempts to place it into the collection.
• Added JetByteTools::IO::CSortedBufferChain::PeekTail() and JetByteTools::IO::CSortedBufferChain::Detach() due to changes in JetByteTools::IO::IIterateableBufferChain.

Version 6.7

• Removed JetByteTools::IO::CLowContentionBufferAllocator and JetByteTools::IO::CTLSBufferAllocator.
• Added JetByteTools::IO::CBufferBasedBufferAlloctor which is a simple shim to allow an instance of JetByteTools::IO::IBuffer to be used as an implementation of JetByteTools::IO::IAllocateBuffers.
• Removed JetByteTools::IO::IIOPool::DispatchToAll() as it was only required for issuing CancelIO() calls to all I/O threads on XP where CancelIOEx() wasn't available.
• Added an overload of JetByteTools::IO::CNonPooledBuffer::Create() that takes a bufferSize and a pointer to data and a data length so that you can create a buffer that initially contains some data but that is larger than that data.
• Added lots of standard buffer functionality to JetByteTools::IO::CNonPooledBuffer before deprecating it in favour of normal buffers obtained via JetByteTools::IO::IAllocateBuffers::AllocateCustomSizedBuffer().
• Breaking change JetByteTools::IO::CAsyncFileReader, JetByteTools::IO:: CAsyncFileWriter, JetByteTools::IO::CAsyncFileWriterEx and JetByteTools::IO::IAsyncIOStream now work in terms of JetByteTools::IO:CSmartBuffer where possible. This potentially reduces the reference counting activity on the buffers.
• Removed JetByteTools::IO::CAsyncFileWriter::ExecuteWritesOnCallingThreadIfSafe as it's the same as JetByteTools::IO::CAsyncFileWriter::ExecuteWritesOnCallingThread now that we no longer support Windows XP.
• Added JetByteTools::IO::IBuffer::GetTotalLength() which returns the length of a set of buffers defined using an array of WSABUF structures.
• Bug fixes to JetByteTools::IO::CBuffer around the usage of m_maxBytesToRead.
• Added JetByteTools::IO::CBufferChain::CopyBufferChain() which uses an instance of JetByteTools::IO::CBufferChain::IAllocateBufferHandles to create a duplicate of a given buffer chain where the duplicate contains handles to the buffers in the original chain.
• Deprecated JetByteTools::IO::IAllocateMultiBufferHandles and the concept of "multi buffer handles".

Version 6.6.5

• Added JetByteTools::IO::IBuffer::OnBufferAddedToPool(), JetByteTools::IO::IBuffer::OnBufferRemovedFromPool(), JetByteTools::IO::IManageBufferLifeCycle::OnBufferAddedToPool() and JetByteTools::IO::IManageBufferLifeCycle::OnBufferRemovedFromPool(). these allow for correct management of dynamically allocated buffer data. Previously JetByteTools::IO::IMonitorBufferAllocation::OnBufferAllocated() was called whenever a buffer was allocated from the allocator OR a custom pool and JetByteTools::IO::IMonitorBufferAllocation::OnBufferReleased() was only called when the buffer was released to the allocator. This made it impossible to manage dynamically allocated buffer data that was created and destroyed by a derived allocator object using the monitoring interface to monitor the underlying allocator. Now JetByteTools::IO::IMonitorBufferAllocation::OnBufferReleased() is called when the buffer is added to a custom pool and this allows the monitor to match allocations and releases exactly.
• Added JetByteTools::IO::IAllocateBuffers::AllocateCustomSizedBuffer() which allows you to allocate a buffer of a specific size (larger than the standard pooled buffer size for the allocator) which is not pooled. Note that if you request a size that is less than or equal to the standard pooled buffer size then you get a standard pooled buffer. Larger buffers are not pooled. This functionality superceeds the use of JetByteTools::IO::CNonPooledBuffer and is preferable as the buffer provided has the same number of userdata slots as all other buffers that are allocated by the allocator concerned.
• Added optional range checking to "user data" access in JetByteTools::IO::CBuffer and JetByteTools::IO::CLockFreeBuffer, define JETBYTE_ILLEGAL_BUFFER_USER_DATA_EXCEPTIONS to enable this.
• Added the ability to pass JUST a custom allocator into the constructor of JetByteTools::IO::CRotatingAsyncFileLog and allow the file log to manage the other resources that it needs directly. Previously you had to provide all of the resources or none.
• Added JetByteTools::IO::CRotatingAsyncFileLog::SetCallback() which allows you to plug an instance of JetByteTools::IO::CAsyncFileWriter::Callback in to the log and for it to be passed any callback messages. This makes it easy to log errors or times when the write limiter is in operation by passing in an instance of JetByteTools::IO::CLoggingAsyncFileWriterCallback.

Version 6.6.4

• Bug fix to JetByteTools::Win32::CBuffer and JetByteTools::Win32::CLockFreeBuffer to make code take notice of when m_maxBytesToRead is set. This was causing issues with WebSockets over SSL where the WebSocket code was setting a max read value and the SSL connector was ignoring it and providing more data than it should.
• Adjusted all includes to remove relative paths and instead be absolute in relation to the library root. So, rather than include "..\Blah.h" it would always be include "JetByteTools\Lib\Blah.h" this is due to a new warning in Visual Studio 2015 update 1.

Version 6.6.3

• Ran Visual Lint using Gimpel PC Lint on all code and adjusted to remove warnings and fix bugs.
• Removed all use of exception specifications. We only ever used throw() but that's now gone too.
• Protected non-virtual destructors on interfaces are now virtual even though they you can't delete the object via the interface.
• All destructors that could throw exceptions now have optional "log and swallow" exception handlers which are enabled by default. This is better than ignoring the problem and being faced with a call to std::terminate() which can be hard to track down.
• Bug fix to JetByteTools::IO::CBuffer::Clear() which now correctly sets m_ioSize to zero.
• Bug fix to JetByteTools::IO::CBufferList::BufferData so that it cannot access pBuffer before it's initialised.
• Bug fix to JetByteTools::IO::CLockableBufferProcessor::~CLockableBufferProcessor() to remove potential buffer leak.
• Changed JetByteTools::IO::CNonPooledBuffer so that it doesn't have to be immutable. You can now create a non-pooled buffer and add data to it after creation.
• Changed JetByteTools::IO::CRotatingAsyncFileLog::DestroyFileWriter() so that if there's an error after the writer has been destroyed then 0 is passed to the OnError() callback rather than the deleted instance of the now dead writer.
• Added an override for JetByteTools::IO::IPoolBuffers::Allocate() which doesn't take an allocator.
• Added JetByteTools::IO::CBufferChain::Detach(), JetByteTools::IO::CBufferChain::Attach() and JetByteTools::IO::CBufferChain::Splice(). These allow you to take a buffer chain and 'detach' it from the buffer chain object so that you can work in terms of a single buffer (with the additional buffers chained on in the normal way but inaccessible). You can then take such a buffer and 'attach' it back to a buffer chain object. This allows you to pass a buffer chain through an interface which only understands single buffers. Splice allows you to take an existing buffer chain and add a 'detached' buffer chain to the end of it.
• Added JetByteTools::IO::CBufferChain::AvailableSpace(), JetByteTools::IO::CBufferChain::HasAvailableSpace() these have also been added to JetByteTools::IO::CBufferChainStoresNulls, JetByteTools::IO::CSortedBufferChain and the various buffer processors.
• Added JetByteTools::IO::CBufferChain::RemoveAsSingleBuffer() which will either consolidate a chain into the first buffer (if all the data will fit) or create a JetByteTools::IO::CNonPooledBuffer of the required size and return the data in the new buffer.
• Added the concept of a "purge handler" for buffer chains. This comes in the form of an interface JetByteTools::IO::CBufferChain::IHandlePurgedBufferRelease and a new override for JetByteTools::IO::CBufferChain::Purge which takes a purge handler and some user data. If the new version of purge is called the purge handler is called for each buffer purged from the chain and it is responsible for disposing of the purged buffer, normally by calling Release() on it. The reason for this is that it's now possible to have a buffer chain of buffers which are 'detached' buffer chains. When purge is called in this situation a purge handler can now be supplied which recreates the buffer chains and, in turn, purges them. Note that these have also been added to JetByteTools::IO::CBufferChainStoresNulls, JetByteTools::IO::CSortedBufferChain and the various buffer processors.
• Bug fix for JetByteTools::IO::CAsyncFileReader we were checking the validity of data response flags incorrectly.
• Added JetByteTools::IO::CAsyncFileWriter::OpenSuitableFile(), JetByteTools::IO::CAsyncFileWriter::CreateSuitableFile() and JetByteTools::IO::CAsyncFileWriter::TryCreateSuitableFile() which allow you to create a file in the way that an CAsyncFileWriter would.
• Added new constructors for JetByteTools::IO::CAsyncFileWriter and JetByteTools::IO::CAsyncFileWriterEx that take a filename and a JetByteTools::Win32::CSmartHandle to an open file.
• Changed constructor for JetByteTools::IO::CAsyncFileWriter that previously took a HANDLE to take a JetByteTools::Win32::CSmartHandle
• Added JetByteTools::IO::CBufferAllocator::GetNumActive() and JetByteTools::IO::CBufferAllocator::GetNumPooled()

Version 6.6.2

• Changes to remove non-trivial, function level static objects from the code, the construction of which is problematic in multi-threaded code.
• Added JetByteTools::IO::IBufferBase::GetSpace() which returns the available space in a buffer, size - used.
• Added JetByteTools::IO::IBuffer::GetTotalSpace() which returns all available space in a buffer, this is GetSpace() plus any space that is currently unused at the front of the buffer due to calls to Consume().
• Added JetByteTools::IO::IBuffer::RemoveSpaceAtFront() which compacts a buffer by removing any unused space at the front and copying any data back towards the front of the buffer.
• Removed the slight 'optimisation' in JetByteTools::IO::CBuffer::Consume() which led it to behave as JetByteTools::IO::CBuffer::ConsumeAndRemove() if there would be less than 100 bytes remaining in the buffer after the call.
• Changed JetByteTools::IO::IBuffer::MakeSpaceAtFront() so that it takes an optional value which indicates how much space must be available at the rear of the buffer. This allows us to be able to create space at the front only if there's enough space in the buffer for the space we need at the front and rear of the buffer.
• Bug fix to JetByteTools::IO::CBufferChain::AddDataToBufferChain() to allow for passing in an empty list of buffers to add.
• Bug fix to JetByteTools::IO::CBufferChain::ConsoliateData() to ensure that buffers that we attempt to consolidate are writeable.
• Changed JetByteTools::IO::CBufferChainStoresNulls so that you can pass it an instance of JetByteTools::IO::IAllocateBuffer in its constructor and it can then use that to allocate a new empty buffer if the number of 'null buffers' stored becomes too great. This effectively removes the limit on the number of 'null buffers' that can be stored between non-null buffers.
• JetByteTools::IO::IBuffer now derives from JetByteTools::Win32::CIntrusiveRedBlackTreeNode which allows for buffers to be placed in non-intrusive containers.
• Added JetByteTools::IO::CSequencedBufferCollection which is a collection based on JetByteTools::Win32::TIntrusiveRedBlackTree which stores the buffers in sequence number order.
• Changed JetByteTools::IO::CSortedBufferChain so that it caches whether you can get the next buffer or not. This reduces the work that needs to be done to find out if you can get the next buffer.

Version 6.6.1

• Bug fix to the allocation and creation of JetByteTools::IO::CNonPooledBuffer which was failing to force the correct alignment. See the JETBYTE_IO_IBUFFER_ALIGNMENT_REQUIREMENT changes in version 6.6 for more details
• Added JetByteTools::IO::CTimeChangeAwareRotatingAsyncFileLog, which is a rotating async file log which includes a JeyByteTools::IO::CTimeChangeNotificationMonitor.

Version 6.6

• Much of the locking in this library has been updated to use the new locks, see Win32Tools for details.
• Removed some cout debug tracing from JetByteTools::IO::CAsyncFileLog.
• Added an alignment restriction to buffers derived from JetByteTools::IO::IBuffer. All such buffers must be aligned on a JETBYTE_IO_IBUFFER_ALIGNMENT_REQUIREMENT byte boundary (currently 16). This is to facilitate using some "spare" bits in the resulting pointers for other purposes. At present only JetByteTools::IO::CBufferChainStoresNulls uses this functionality.
• Added JETBYTE_CRASH_DUMP_ON_NEXT_BUFFER_REF_CHANGE_AFTER_ILLEGAL_CHANGE which causes crash dumps to be created the next time AddRef() or Release() is called on a buffer after an illegal ref count change (over-release or under-release) has been detected.
• Added JetByteTools::IO::IPoolBuffers and JetByteTools::IO::IAddBuffersToPool and JetByteTools::IO::CCustomPoolSmartBuffer which are used to create and manage "custom buffer pools". Buffers can now be released or allocated from these custom buffer pools with the pool acting as a local pool which can release buffers directly to an allocator if it is full and obtain buffers from an allocator if it is empty. These custom pools are used to provide "per socket" buffer pools which improve performance by allowing each socket to pool a small number of buffers for later re-use and therefore avoid accessing a buffer allocator. Normally the socket's pool will only be accessed from a single thread and so this reduces contention for the shared buffer allocator.
• Added JetByteTools::IO::IBuffer::SetMaxRead() which will limit the amount of data that can be read into a buffer on the next read - it temporarily reduces the buffer's available space. This can be used if you will immediately split a buffer into pieces if it contains more than one message and if you know the size of the message that you're reading and it happens to be smaller than your buffer size.
• Added JetByteTools::IO::IBuffer::ReadCompleted() which is used in place of JetByteTools::IO::IBuffer::Use() when a read completes.
• Added JetByteTools::IO::IBuffer::SetOperationData(), JetByteTools::IO::IBuffer::GetOperationData() and JetByteTools::IO::IBuffer::GetOperationSequenceNumber() which are used by the SocketTools library's operation queueing code.
• Added JetByteTools::IO::IBuffer::IsReadOnly() and JetByteTools::IO::IBuffer::GetWritableBuffer(). These are mainly for use when you want to change a buffer's contents but the buffer could be a read only buffer, such as a JetByteTools::IO::CBufferHandle. They allow you to safely convert the read only buffer to a writable one (by making a copy of the data in a new buffer).
• Added JetByteTools::IO::IManageBufferHandleLifeCycle which is used by JetByteTools::IO::CBufferHandle to allocate a normal buffer when converting from read only to writable.
• Added a constructor to JetByteTools::IO::CBufferAllocator which turns off buffer reference tracking for buffers created from the allocator - use with care.
• JetByteTools::IO::CTLSBufferAllocator has been deprecated and is no longer available unless you define JETBYTE_DEPRECATE_TLS_BUFFER_ALLOCATOR to 0 in Config.h. This class is viewed as being of limited use now that per socket pooling is available.
• JetByteTools::IO::CLowContentionBufferAllocator has been deprecated and is no longer available unless you define JETBYTE_DEPRECATE_LOW_CONTENTION_BUFFER_ALLOCATOR to 0 in Config.h. This class is viewed as being of limited use now that per socket pooling is available.
• Removed the optional "spin count" argument to the JetByteTools::IO::CBufferAllocator constructor. The allocator now uses the new JetByteTools::Win32::CLockableObject as a lock and this does not support setting a spin count. Besides, the varied lock hold times within the allocator always meant that setting a useful spin count was difficult to achieve.
• Added JetByteTools::IO::IIterateableBufferChain which both JetByteTools::IO::CBufferChain and JetByteTools::IO::CSortedBufferChain implement. This allows you to perform a non-destructive walk along a buffer chain.
• JetByteTools::IO::IBufferChain::Purge() now returns the number of buffers purged.
• Added JetByteTools::IO::IBufferChain::TotalBytes() and JetByteTools::IO::IBufferChain::GetTotalBytesAndAvailableSpace().
• Added various "Try" versions of the Add and GetNext functions in JetByteTools::IO::IBufferChain. These can only really fail for sorted buffer chains and do so if the sequence number of the buffer about to be inserted is already present in the chain.
• All buffers now have a default user data slot which can be used to chain them together in a buffer chain. This generally precludes the need to allocate custom user data slots for buffer chains unless you need to store a single buffer in multiple chains (for which you would need a unique user data slot per chain). Buffer chain constructors now take a default value for the user data slot to use.
• JetByteTools::IO::CBufferChainStoresNulls now uses the "extra space" in the aligned pointers for instances of JetByteTools::IO::IBuffer (see above for alignment requirements) to store the count of "null buffers" between actual buffers. This removes the need for it to use a second user data slot just for this purpose.
• Added static functions JetByteTools::IO::CBufferChain::AddDataToBufferChain() which allows you to add data to an existing chain of buffers and will expand the chain to contain the new data if necessary.
• Added static function JetByteTools::IO::CBufferChain::ConsolidateData() which takes a buffer chain and moves data around to use the least number of buffers.
• Added support for user data to JetByteTools::IO::CBufferHandle. This means that each handle can have its own user data.
• JetByteTools::IO::CBufferReferenceTracker has been tuned a little with regards to custom context depths for some functions and now supports the concept of "instances". See the release notes for the Win32Tools lib, especially JetByteTools::Win32::CReferenceTracker. The number of instances supported can be configured in Config.h by defining JETBYTE_BUFFER_TRACKING_INSTANCES which defaults to 1. Note that tracking multiple instances increases the amount of memory required when tracking references and so multiple instances should only be turned on when required.
• Added JetByteTools::IO::IAllocateBuffers::AllocateDefaultUserDataIndices() which should be called by all buffer allocators to set up the default user indices that all buffers must support.
• Removed the optional bool forceDispatchToPool from the JetByteTools::IO::IAsyncIOStream::Write() methods.
• Added an overload to JetByteTools::IO::IAsyncIOStream::Write() which takes an JetByteTools::IO::IIterateableBufferChain of buffers. This can allow for efficient management of the locks required to build and send a series of buffers in one write.
• Added some helper functions to JetByteTools::IO::IBuffer which help with dealing with the alignment required for all instances of the class and also help access the 'pointer' and the 'extra space' that we're using in pointers to instances of this interface.
• Added JetByteTools::IO::IBuffer now has a constructor which validates that derives classes are aligned as expected.
• Added JetByteTools::IO::IIOPool::GetNumberOfThreads() and JetByteTools::IO::IIOPool::DispatchToAll().
• Added JetByteTools::IO::CIOPoolBase::GetNumberOfThreads() and JetByteTools::IO::CIOPoolBase::DispatchToAll(). These are only intended to be used to dispatch a CancelIo() request to all threads in an I/O thread pool - this is required by a bug fix for XP (which doesn't have CancelIoEx()). Note that JetByteTools::IO::IIOPool::DispatchToAll() is likely to exhibit poor performance characteristics as it needs to block threads in the I/O pool so that it can be sure to dispatch an operation to each thread. Under heavy load this will seriously affect the scalability of the I/O pool.
• Added JetByteTools::IO::IMonitorIOPool::OnIOPoolThreadStarted() and JetByteTools::IO::IMonitorIOPool::OnIOPoolThreadStopped() both of which are called from the thread in question.
• Added JetByteTools::IO::IMonitorIOPool::OnIOPoolWorkItemsDequeued().
• Changed the content of some exception messages from JetByteTools::IO::CInOrderBufferList.
• Added JETBYTE_DEPRECATE_IN_ORDER_BUFFER_LIST which currently defaults to 0 and which, when defined to 1, removes the JetByteTools::IO::CInOrderBufferList from the source tree. You should replace usages of this class with one of the buffer processors, probably JetByteTools::IO::CSortedBufferProcessor. The define is currently only present to aid in locating and removing all usages of the list. It will actually be deprecated in the next release.
• Added JetByteTools::IO::CIOPoolEx which is an I/O pool which uses GetQueuedCompletionStatusEx() to retrieve multiple completions in one call. Moved most of the common code into JetByteTools::IO::CIOPoolBase which JetByteTools::IO::CIOPool also now derives from.
• Added JetByteTools::IO::IProvideWorkItems::GetNextWorkItems() and JetByteTools::IO::IProvideWorkItems::PutBackWorkItems().
• Bug fix in JetByteTools::IO::CRotatingAsyncFileLog where we now obtain the log's lock before setting the state to shutting down in the destructor. This prevents a race condition that was discovered in testing.
• Added an optional argument to the constuctor of JetByteTools::IO::CSortedBufferChain which allows you to pass in a function that obtains the sequence number from the buffer. This defaults to a function which uses the buffer's internal sequence number but you could alternatively use a function which returns the buffer's operation sequence number.
• Added JetByteTools::IO::CSortedBufferChain::NumConsecutiveBuffers() which returns the number of buffers which can be processed before the chain will need to halt processing whilst awaiting a buffer of the correct sequence number. This will always be less than or equal to JetByteTools::IO::CSortedBufferChain::Size()
• Added JetByteTools::IO::CSortedBufferProcessor which adds the ability to set the initial sequence number and reset the underlying sorted buffer chain.
• Bug fixes to JetByteTools::IO::CUnsortedBufferProcessor to allow correct operating with JetByteTools::IO::CBufferChainStoresNulls.
• Bug fix to JetByteTools::IO::CBuffer when socket reference tracking is enabled, but references for a particular buffer are not being tracked.
• Bug fix to the change from 6.5.9 to allow it to compile on Visual Studio 2005 with no platform SDK installed - a cast is required to resolve ambiguity with InterlockedIncrement().
• You can now call JetByteTools::IO::CBufferAllocator::RequestUserDataSlot() (and the equivalent on all other buffer allocators) after a socket has been allocated by the allocator to obtain the index of a user data slot that has been registered before the user data indices were locked.
• Bug fix to JetByteTools::IO::CBuffer::ConsumeAndRemove() and JetByteTools::IO::CLockFreeBuffer::ConsumeAndRemove(). We now correctly return false if m_used, m_startOffset and bytesToRemove are all 0.
• Added JetByteTools::IO::CBufferChainStoresNulls::Dump() which is used within the unit tests and handy for debugging odd situations...
• Added support for JetByteTools::IO::CBufferHandle::AllocateNewBuffer() to allocate a buffer if it can, rather than always throwing an exception.
• Added JetByteTools::IO::CInputFilterProcessor and JetByteTools::IO::IProcessingInputFilterProcessor, which reduce the complexity of processing input whilst maintaining two lists of buffers (filled data buffers and pending empty buffers) without locking during processing. We only lock when buffers are added to the lists. Currently only used in the WebSockets code but relevant to all input filters.

Version 6.5.9

• No changes.

Version 6.5.8

• Reduced the size of IBuffer::SequenceNumber from size_t to unsigned long. This is related to the bug fix in JetByteTools::Socket::CSequencedStreamSocket::SequenceData.
• Added some more information to the exceptions thrown from JetByteTools::IO::CInOrderBufferList.

Version 6.5.7

• Updated our support of Visual Studio 2012 to the RTM version. Added a few more warning suppressions. Fixed the solution file format so that it's actually a 2012 solution file and not a 2010 solution file using the 2012 tool chain.

Version 6.5.6

• Updated our support of Visual Studio 2012 (11) to the RC version. Added a few more warning suppressions. Renamed the output directories. Renamed the solutions and projects from .11. to .2012.

Version 6.5.5

• Fixed some warnings generated by /analyze.
• Bug fix. Removed the exception thrown in JetByteTools::IO::CAsyncFileWriter::HandleWriteRequest() when JETBYTE_FILE_WRITER_SKIP_COMPLETION_PORT_ON_SUCCESS is enabled.
• Bug fix. Correctly track read completions in JetByteTools::IO::CAsyncFileReader::IssueReadRequest() when JETBYTE_FILE_WRITER_SKIP_COMPLETION_PORT_ON_SUCCESS is enabled.

Version 6.5.4

• Changed JetByteTools::IO::IAllocateBufferHandles::Flush() so that it returns a bool indicating if buffers were active when the flush was done. This brings it in line with JetByteTools::IO::IAllocateBuffers.
• Changed the JetByteTools::IO::IAsyncIOStream::Write() methods so that they take an optional bool that enables you to force the write to go via the I/O pool even if I/O marshalling is turned off.
• Changed JetByteTools::IO::CAsyncFileLog to monitor its own write thread to remove the chance that it might hang during destruction if the thread has terminated due to an exception.

Version 6.5.3

• No changes.

Version 6.5.2

• Bug fixes to JetByteTools::IO::CBufferChain and JetByteTools::IO::CSortedBufferChain.
• Added JetByteTools::IO::CLockableBufferProcessor::PutBackAndLock().

Version 6.5.1

• Fixed a typo in the text of an exception.

Version 6.5

• Added a variation of JetByteTools::IO::IBuffer::SplitBufferFromFront() which takes a start offset and a length so that you can remove `start + length` from the source buffer and end up with `length` in the destination buffer.
• Added JetByteTools::IO::IBuffer::Consume() which moves a 'start offset' inside the buffer but does not move the data as JetByteTools::IO::IBuffer::ConsumeAndRemove() does.
• JetByteTools::IO::IBuffer::ConsumeAndRemove() now returns true if the buffer is empty after the bytes are removed.
• Added JetByteTools::IO::IBuffer::MakeSpaceAtFront() which will either give you back space that was previously consumed with JetByteTools::IO::IBuffer::Consume() OR will copy the esisting buffer contents along in the buffer to make more space at the start.
• Added JetByteTools::IO::IBufferBase::ReduceUsed() which will remove bytes from the end of the buffer.
• Added buffer chains and buffer processors. These are intended to be a more flexible and performant replacement to JetByteTools::IO::CInOrderBufferList, JetByteTools::IO::CBufferList, and JetByteTools::IO::CSequentialBufferList. Buffer chains build a singly linked list of buffers using a user data slot for the next pointer. As such they do not require additional memory to be allocated or released when performing operations on the chains. JetByteTools::IO::CBufferChain is a simple list from which you can add to the front or back and which can have items removed from the front. JetByteTools::IO::CBufferChainStoresNulls is similar to JetByteTools::IO::CBufferChain except that it keeps track of null pointers as well as buffers, use JetByteTools::IO::CBufferChainStoresNulls::IsEmpty() or JetByteTools::IO::CBufferChainStoresNulls::Size() to tell you when the chain is empty as JetByteTools::IO::CBufferChainStoresNulls::GetNext() can return null to indicate that a null pointer was inserted into the chain at that point. JetByteTools::IO::CSortedBufferChain is a list that stores the buffers in ascending sequence number order; much like JetByteTools::IO::CInOrderBufferList does. Buffer processors, such as JetByteTools::IO::CBufferProcessor, JetByteTools::IO::CLockableBufferProcessor and JetByteTools::IO::CUnsortedBufferProcessor provide the 'processing' functionality of JetByteTools::IO::CInOrderBufferList with buffer chains. A JetByteTools::IO::CBufferProcessor given a JetByteTools::IO::CSortedBufferChain to work on provides the same functionality as a JetByteTools::IO::CInOrderBufferList without any of the memory allocation overhead required for adding and removing elements.
• Increased the size of the type used to store the number of buffers that can be pooled in a buffer allocator from unsigned short to unsigned long.
• Added JetByteTools::IO::CSequentialBufferList::AddBuffer() and JetByteTools::IO::CSequentialBufferList::AddBufferToFront().
• Added JetByteTools::IO::CNonPooledBuffer a buffer that isn't pooled...

Version 6.4

• Added JetByteTools::IO::ILimitPendingWrites which is a write limiter that can be shared between instances of JetByteTools::IO::CAsyncFileWriter and its derivatives.
• Breaking Change JetByteTools::IO::CAsyncFileWriter, JetByteTools::IO::CAsyncFileWriterEx, JetByteTools::IO::CAsyncFileLog and JetByteTools::IO::CRotatingAsyncFileLog all now take an instance of JetByteTools::IO::ILimitPendingWrites rather than a long to limit the number of writes that can be pending on them.
• Major changes to JetByteTools::Win32::CAsyncFileReader which now means that it works as you'd expect it to and is similar to JetByteTools::Win32::CAsyncFileWriter.
• Added JetByteTools::IO::IMonitorAsyncFileWriter
• Added JetByteTools::IO::IMonitorAsyncFileReader
• Bug fix to JetByteTools::IO::CAsyncFileWriter which hopefully fix some race conditions in object destruction and how callbacks are issued. But then I thought I'd fixed them all last time.
• Added JETBYTE_ILLEGAL_BUFFER_REFERENCE_COUNT_CRASH_DUMP_CREATION with a default of 0. When set to 1 any I/O buffer over-release will generate a crash dump using JetByteTools::Win32::CMiniDumpGenerator.
• Added JetByteTools::IO::CBufferList::DetachContiguousMemory() which returns you the data portions of the buffers in the list as one contiguous block of memory.
• Breaking Change removed JetByteTools::IO::IIOPool::GetThreadsTlsIndex() and JetByteTools::IO::IIOPool::GetPoolThreadsIdentifier() and replaced the functionality with JetByteTools::IO::IIOPool::JoinLogicalThreadGroup().
• Breaking Change JetByteTools::IO::CIOPool constructors now do not take a thread identifier, the thread identifier is generated for each pool.
• Bug fix JetByteTools::IO::CLockFreeBuffer and JetByteTools::IO::CLockFreeBufferAllocator are now only usable on Windows XP and later. Previously they simply wouldn't compile on Win2k.
• Added JetByteTools::IO::CSequentialBufferList - a buffer list with the same logical interface as JetByteTools::IO::CInOrderBufferList but which simply stores the buffers in the order that they're given to it.
• Added JetByteTools::IO::CTLSBufferAllocator - a buffer allocator that performs better in multi-threaded situations by avoiding contention by keeping per thread pools rather than a single pool shared by all threads.

Version 6.3.3

• No changes.

Version 6.3.2

• No changes.

Version 6.3.1

• No changes.

Version 6.3

• Lots of white space changes which make comparing actual changes with 6.2 quite hard. Sorry.
• Added JetByteTools::IO::IBuffer::CLowContentionBufferAllocator which is a pool of allocators which are used in a round robin style to allocate buffers. This needs very careful tuning with regards to the number of allocators and the number of threads to actually work properly but it can give quite a performance gain in some circumstances. See here for more details.
• Added JetByteTools::IO::IBuffer::WeOwnOnlyReference() which returns true when the reference count of a buffer is 1.
• Added the concept that the buffer allocator that was used to allocate a given buffer might be different to the allocator that it uses when JetByteTools::IO::IBuffer::Allocate() and JetByteTools::IO::IBuffer::DuplicateBuffer() are called. This allows for some optimisations in the JetByteTools::IO::CLowContentionBufferAllocator to be more efficient.
• Added JetByteTools::IO::CBufferAllocator::SetAllocatorForBufferToUse() which can be used to set the buffer allocator that is passed to buffer instances for use when allocating new buffers. This allows for some optimisations in the JetByteTools::IO::CLowContentionBufferAllocator to be more efficient.
• Added an optional performance optimisation for JetByteTools::IO::CBufferAllocator. Define JETBYTE_PERF_NO_ACTIVE_BUFFER_LIST to 1 in your Config.h and the allocator doesn't maintain an active buffer list. This improves performance fractionally.
• Breaking Change JetByteTools::IO::IMonitorBufferAllocation now has two new functions. OnBufferAllocationContention() and OnBufferReleaseContention() these are called if monitoring of contention during buffer allocation and release in JetByteTools::IO::CBufferAllocator is enabled by defining JETBYTE_PERF_BUFFER_ALLOCATION_CONTENTION_MONITORING to 1 in your Config.h.
• Added JetByteTools::IO::CBufferList::Begin() and JetByteTools::IO::CBufferList::End() to enable traversal of the buffers that are stored in the buffer list.
• Added JetByteTools::IO::IHandleFileCreationFailure which is used by JetByteTools::IO::CRotatingAsyncFileLog to enable you to recover from failures to open files. You can change the file name if required or tell the calling code not to retry the operation.
• Added JetByteTools::IO::CRetryAndRenameFileCreationFailureHandler which implement JetByteTools::IO::IHandleFileCreationFailure and allows a configurable number of reties with a configurable length of delay between them and the option to rename the file that's being created.
• Added JetByteTools::IO::IManageWorkerThreads which allows worker threads to call back to their creator to signal initialisation and shutdown.
• Breaking Change JetByteTools::IO::IMonitorIOPool has a new function, OnIOPoolDispatch() which is called when an operation is manually dispatched to an I/O pool thread. Note that this is not called for automatically dispatched I/O completions.
• JetByteTools::IO::IOPool now passes an instance of JetByteTools::IO::IManageWorkerThreads to its worker threads which means that they can call back to it when they initialise and shutdown. This allows derived classes to override these methods to provide per thread initialisation which occurs on the worker thread itself. Useful for initialising COM or whatever on the threads in the I/O pool.
• Added JetByteTools::IO::CLockFreeBufferAllocator::EnlargePool() so that you can enlarge the pool of buffers before use.

Version 6.2

• Fixed a race condition bug in JetByteTools::IO::CAsyncFileWriter where the interaction between the class destructor and/or the notification generated by a final write completing could cause destruction problems either with regard to the writer being deleted before the callback returns or the class being deleted before the final write notification had been completed; this all pretty much depended on how you waited for the final write when cleaning up the file writer.
• Added JetByteTools::IO::IBuffer::DuplicateBuffer() which allocates a new buffer from the same allocator used by the existing buffer and copies the existing data into the new buffer before returning it.
• We now check for numeric overflow when we're calculating the total size of the buffers in JetByteTools::IO::CMultiBufferHandle::GetUsed().
• Fixed a bug in JetByteTools::IO::CAsyncFileWriter::HandleWriteRequest() which could cause a race condition between the buffer allocator's destruction and the last operation that we perform on a buffer that has been allocated from it. Basically we signal that the last write is complete after we've finished fiddling with the buffers that we've been using.
• Added conditional code to allow FILE_SKIP_SET_EVENT_ON_HANDLE and FILE_SKIP_COMPLETION_PORT_ON_SUCCESS to be enabled on the file handle used by JetByteTools::IO::CAsyncFileWriter. See the JETBYTE_PERF_FILE_WRITER_SKIP_EVENT_ON_HANDLE and JETBYTE_PERF_FILE_WRITER_SKIP_COMPLETION_PORT_ON_SUCCESS configuration options in Config.h
• Added conditional code to allow FILE_SKIP_SET_EVENT_ON_HANDLE and FILE_SKIP_COMPLETION_PORT_ON_SUCCESS to be enabled on the file handle used by JetByteTools::IO::CAsyncFileReader. See the JETBYTE_PERF_FILE_READER_SKIP_EVENT_ON_HANDLE and JETBYTE_PERF_FILE_READER_SKIP_COMPLETION_PORT_ON_SUCCESS configuration options in Config.h
• Fixed JetByteTools::IO::CBufferAllocator::RequestUserDataSlot() so that it only checks to see if the index collection is locked if an exception is thrown whilst manipulating it.
• Removed <wtypes.h> from IAsyncIOStream.h
• Added JetByteTools::IO::CInOrderBufferList::SetInitialSequenceNumber() and allow the initial sequence number to be passed into the constructor.
• Fixed JetByteTools::IO::CInOrderBufferList sequence number wrap issues.
• Breaking Change All instances of InitiateShutdown() have been changed to BeginShutdown() this is to remove the issue with the Win32 InitiateShutdown() function which is conditionally defined as either InitiateShutdownA() or InitiateShutdownW() and which could then cause issues. The following classes are affected:
  • JetByteTools::IO::IOPool

Version 6.1.1

• Fixed a bug in JetByteTools::IO::CRotatingAsyncFileLog which could cause the date stamp for a log file to end up with a date of 16010101. See here http://www.lenholgate.com/archives/000880.html for more details.
• Fixed a bug in JetByteTools::IO::CRotatingAsyncFileLog which caused the timestamp in the log to include 4 charactes for the milliseconds rather than 3 resulting in 0999 rather than 999.
• Changed how JetByteTools::IO::CBufferReferenceTracker works. You can now get it to include additional call stack context by defining JETBYTE_ADDITIONAL_BUFFER_TRACKING_CONTEXT (in Config.h) to the number of additional frames of context that you require.

Version 6.1

• Added the ability to restrict the number of pending writes for an instance of JetByteTools::IO::CAsyncFileWriter. You can now specify a maxPendingWrites in the constructor and if this is not 0 then a semaphore is created and used to control the number of writes that can be pending at any one time. When the maximum number of writes are pending the dispatch of new writes is delayed and writes effectively become synchronous. This can be used to prevent unconstrained resource usage.
• Added JetByteTools::IO::CAsyncFileWriter::Callback::OnPendingWriteLimit() which is called each time the file writer reaches the limit of pending writes that it can have outstanding at any one time.
• Added the ability to specify a pending write limit to the JetByteTools::IO::CAsyncFileWriter that is used by JetByteTools::IO::CRotatingAsyncFileLog.
• Added the ability to specify a pending write limit to the JetByteTools::IO::CAsyncFileWriter that is used by JetByteTools::IO::CAsyncFileLog.
• Fixed a race condition in how reads were issued by JetByteTools::IO::CAsyncFileReader.
• Added a configuration option, JETBYTE_TRACK_IO_BUFFER_REFERENCES which when defined as 1 causes code to be inserted that tracks the reference counting that occurs on instances of JetByteTools::IO::CBuffer. If a buffer is over released (i.e. release is called on a buffer where the reference count is currently zero) then a trace of all calls to JetByteTools::IO::CBuffer::AddRef() and JetByteTools::IO::CBuffer::Release() will be printed to the debug trace output. If a buffer is destroyed and the reference count is not zero then a trace is also printed. Note that there is a considerable run-time cost for this functionality but it is non invasive and no external code changes are needed. See here http://www.lenholgate.com/archives/000867.html for more details.
• Added JetByteTools::IO::CBufferReferenceTracker which is used to implement the reference tracking code that is detailed above.
• Added the ability to specify that JetByteTools::IO::CBufferAllocator should allocate buffers using VirtualAlloc() with the additional option to allocate buffers on page boundaries. This can be useful if you want to control, exactly, the number of pages that your buffers use so that you can reduce the number of pages locked during I/O operations. Note that the allocator used is pretty simplistic and that it doesn't return memory to the operating system until the allocator is destroyed. See here http://www.lenholgate.com/archives/000853.html for more details.
• Added JetByteTools::IO::CBufferList which is a list which can contain instances of JetByteTools::IO::IBuffer and offsets and data lengths within them. A contiguous view onto these buffers can then be obtained. For example, if you add buffer 1 with an offset of 10 and a length of 10 and then buffer 2 with an offset of 12 and a length of 12 the value returned from JetByteTools::IO::CBufferList::GetTotalDataLength() will be 22 and the memory returned from JetByteTools::IO::CBufferList::GetContiguousMemory() will include 10 bytes of data from buffer 1 starting at offset 10 and 12 bytes from buffer 2 starting at ofset 12. This can be useful for combining fragmented network messages where each message buffer also contains a header that needs to be skipped.
• Added JetByteTools::IO::CSmartBufferList which is a 'smart pointer' for pointers to JetByteTools::IO::CBufferList.
• Changed JetByteTools::IO::IAllocateBuffers::Flush() so that it returns a bool. The function now returns true if there were buffers present when the allocator was flushed.
• Added the ability to specify to an instance of JetByteTools::IO::CBufferAllocator that you don't want it to pool buffers at all.

Version 6.0

• Changes due to the merging of C++Tools and RegistryTools with Win32Tools.
• JetByteTools::IO::CAsyncFileLog::LogMessage() now uses the version of sprintf_s that takes the length of the destination buffer.
• Added JetByteTools::IO::CAsyncFileWriter::GetFileNameIfKnown() which returns the name of the file being written to if it's known; note that at present we do not attempt to find out the name of file handles which are passed to us so we only return the file name if the file name was passed to us in the constructor.
• Added JetByteTools::IO::CAsyncFileWriter::GetFileSize() which returns the current size of the file being written to.
• Added JetByteTools::IO::CRotatingAsyncFileLog::GetCurrentLogFileName() which returns the full name of the current log. This is useful as otherwise it's non-trivial to work out the name of a log that may include time and date details.
• Changes to JetByteTools::IO::IMonitorBufferAllocation::OnBufferAllocated() and JetByteTools::IO::IMonitorBufferAllocation::OnBufferReleased(), they both now get passed the buffer's user data so that they can be used to add or remove user data from buffers.
• JetByteTools::IO::CRotatingAsyncFileLog can now be configured to delete empty log files when a new log file is created. This means that only the log files that contain logged messages are kept.
• Added JetByteTools::IO::CSmartBuffer, this was previously available as JetByteTools::Socket::CSmartBuffer but it should have always been in the IO namespace.
• Added JetByteTools::IO::SplitBufferFromBack(), this is a more efficient way of splitting a buffer than calling JetByteTools::IO::IBuffer::SplitBufferFromFront() as it results in less memory copying; however it returns the data that was removed from the current buffer and leaves the current buffer with the remaining data in it which is the opposite to how JetByteTools::IO::IBuffer::SplitBufferFromFront() works.
• Breaking Change Renamed JetByteTools::IO::IBuffer::SplitBuffer() to JetByteTools::IO::IBuffer::SplitBufferFromFront(). In most cases it would probably be better to use JetByteTools::IO::SplitBufferFromBack() rather than JetByteTools::IO::IBuffer::SplitBufferFromFront() but this requires code changes.

Version 5.2.5

• No changes.

Version 5.2.4

• We now compile with /Wall (in VS2005 and later) to enable all warnings, even those that are disabled by default.
• Added JetByteTools::IO::CAsyncFileWriter::NotifyOnNoWrites() which can be used to call you back when the last pending overlapped write completes. This can then be used to allow 'overlapped' waiting for the final write so that you don't have to block a thread to wait for all writes to complete before deleting a writer.
• Added JetByteTools::IO::IAllocateMultiBuffersHandles, JetByteTools::IO::CMultiBufferHandle and JetByteTools::IO::CMultiBufferHandleAllocator. These allow you to issue 'scatter/gather' style writes. You might have a fixed header and trailer buffer, and a changeable third buffer and with a multi-buffer handle you can issue one write to write all of them. See the Multi Buffer Write example server for details of how to use these classes.
• Added JetByteTools::IO::CRotatingAsyncFileLog which is a log file which with a date and time related name which will close one instance of the log and open a new one with a new name at regular intervals. You can use this to automatically create a new log each hour, day week, etc.
• Added JetByteTools::IO::CBufferAllocator::LockUserDataSlots() and JetByteTools::IO::CLockFreeBufferAllocator::LockUserDataSlots() as required by the change to JetByteTools::Win32::IProvideUserData.
• The constructor for JetByteTools::IO::CBufferHandle are now protected, buffer handles should be allocated via an allocator.

Version 5.2.3

• Some whitespace changes to remove incorrect tabs.
• Added JetByteTools::IO::CBufferHandleAllocator. This provides a pooling allocator for JetByteTools::IO::CBufferHandle objects. Buffer handles are used to broadcast data to multiple clients without needing to copy the data into separate buffers.
• Added JetByteTools::IO::CJobEventManager. This works with the job object support in the Win32 Tools Library to provide an event manager which can work with a JetByteTools::IO::IIOPool.
• Fixed a memory leak in JetByteTools::IO::CMemoryInputOutputStream where we were using delete rather than delete [].
• Added JetByteTools::IO::CInOrderBufferList::Size() which returns the number of buffers in the list.
• Added JetByteTools::IO::IBuffer::GetWSABUFCount(). This returns the number of WSABUFs in the array returned by JetByteTools::IO::IBuffer::GetWSABUF(). At present all buffer implementations return 1 for this, but this will allow for buffers which support 'scatter/gather' style multiple buffer writes.
• Added JetByteTools::IO::IAllocatableBuffer which goes some way to being able to share the pooling aspects of the various buffer allocators.
• Added JetByteTools::IO::CIOPool::SetThreadName() which allows you to change the name of the worker threads that are managed by the pool. The constructor now sets the name of these threads to "IOPool" by default. Note that this must be called before calling JetByteTools::Win32::CIOPool::Start() for it to have an effect.

Version 5.2.2

• Added JetByteTools::IO::IIOPool::GetHandle() and JetByteTools::IO::IIOPool::TryAssociateDevice() and associated changes to JetByteTools::IO::CIOPool.
• Changes to JetByteTools::IO::CAsyncFileWriter to allow much more control as to how the asynchronous file writes are executed. See http://www.lenholgate.com/archives/000765.html for more details.
• Added JetByteTools::IO::CAsyncFileWriterEx which now contains the simple scatter/gather file write logic that used to live in JetByteTools::IO::CAsyncFileWriter.
• Fied some things in JetByteTools::IO::CAsyncFileReader. We now use FILE_FLAG_SEQUENTIAL_SCAN when opening the file, we can attach to an existing file handle, the file handle is stored in a JetByteTools::Win32::CSmartHandle to avoid any chance of resource leakage, the callback now takes a reference to a buffer rather than a pointer and we recognise ERROR_BROKEN_PIPE as an 'end of file' indication so that the class can be used to read from pipes as well as files.
• Changed JetByteTools::IO::CAsyncFileWriter to report (in the exception that's thrown) the name and path of a file if it fails to open a file due to an ERROR_PATH_NOT_FOUND error. This means that we throw an JetByteTools::Win32::CException in this case rather than the JetByteTools::Win32::CWin32Exception that was thrown in previous versions.

Version 5.2.1

• VS 2008 support - Adding projects and solutions and excluding warning 4627...
• This is the first release built using continuous integration, some project file fixes to fix incorrect output directories, etc so that x64 and x86 builds can be done in complete isolation.
• Bug fix in JetByteTools::IO::CAsyncFileWriter to release the buffer that was used during a write before we signal that the write is complete, this prevents a resource leak or crash when the destructor is waiting for the final write to complete before cleaning up.

Version 5.2

• x64 port - Some data types have changed...
• Some tightening up on const.
• Added JetByteTools::IO::CAsyncFileLog which is a high performance implementation of the JetByteTools::ILogMessages interface.
• Added JetByteTools::IO::IStream which is a bit of a hack, it's just a place to scope a useful data type.
• If JETBYTE_HAS_INTERLOCKED_64 (see Admin.h) is defined to 1 the JetByteTools::IO::CAsyncFileWriter will use interlocked operations, rather than a critical section, to manipulate the file write offset.
• JetByteTools::IO::CAsyncFileWriter now supports a simple 'gather' style version of Write() which can write multiple buffers in a single call.

There were no release notes for this library prior to version 5.2

---