Revision History

Reduced compile times. (Note that some programs may need to add additional #includes, e.g. if the program uses boost::array but does not explicitly include <boost/array.hpp>.)
Reduced the size of generated code.
Refactored deadline_timer implementation to improve performance.
Improved multiprocessor scalability on Windows by using a dedicated hidden thread to wait for timers.
Improved performance of asio::streambuf with async_read() and async_read_until(). These read operations now use the existing capacity of the streambuf when reading, rather than limiting the read to 512 bytes.
Added optional separate compilation. To enable, add #include <boost/asio/impl/src.cpp> to one source file in a program, then build the program with BOOST_ASIO_SEPARATE_COMPILATION defined in the project/compiler settings. Alternatively, BOOST_ASIO_DYN_LINK may be defined to build a separately-compiled Asio as part of a shared library.
Added new macro BOOST_ASIO_DISABLE_FENCED_BLOCK to permit the disabling of memory fences around completion handlers, even if thread support is enabled.
Reworked timeout examples to better illustrate typical use cases.
Ensured that handler arguments are passed as const types.
Fixed incorrect parameter order in null_buffers variant of async_send_to (#4170).
Ensured unsigned char is used with isdigit in getaddrinfo emulation (#4201).
Fixed handling of very small but non-zero timeouts (#4205).
Fixed crash that occurred when an empty buffer sequence was passed to a composed read or write operation.
Added missing operator+ overload in buffers_iterator (#4382).
Implemented cancellation of null_buffers operations on Windows.

Improved performance.
Reduced compile times.
Reduced the size of generated code.
Extended the guarantee that background threads don't call user code to all asynchronous operations (#3923).
Changed to use edge-triggered epoll on Linux.
Changed to use timerfd for dispatching timers on Linux, when available.
Changed to use one-shot notifications with kqueue on Mac OS X and BSD platforms.
Added a bitmask type ip::resolver_query_base::flags as per the TR2 proposal. This type prevents implicit conversion from int to flags, allowing the compiler to catch cases where users incorrectly pass a numeric port number as the service name.
Added #define NOMINMAX for all Windows compilers. Users can define BOOST_ASIO_NO_NOMINMAX to suppress this definition (#3901).
Fixed a bug where 0-byte asynchronous reads were incorrectly passing an error::eof result to the completion handler (#4023).
Changed the io_control() member functions to always call ioctl on the underlying descriptor when modifying blocking mode (#3307).
Changed the resolver implementation to longer require the typedefs InternetProtocol::resolver_query and InternetProtocol::resolver_iterator, as neither typedef is part of the documented InternetProtocol requirements. The corresponding typedefs in the ip::tcp, ip::udp and ip::icmp classes have been deprecated.
Fixed out-of-band handling for reactors not based on select().
Added new BOOST_ASIO_DISABLE_THREADS macro that allows Asio's threading support to be independently disabled.
Minor documentation improvements.

Added a new HTTP Server 4 example illustrating the use of stackless coroutines with Asio.
Changed handler allocation and invocation to use boost::addressof to get the address of handler objects, rather than applying operator& directly (#2977).
Restricted MSVC buffer debugging workaround to 2008, as it causes a crash with 2010 beta 2 (#3796, #3822).
Fixed a problem with the lifetime of handler memory, where Windows needs the OVERLAPPED structure to be valid until both the initiating function call has returned and the completion packet has been delivered.
Don't block signals while performing system calls, but instead restart the calls if they are interrupted.
Documented the guarantee made by strand objects with respect to order of handler invocation.
Changed strands to use a pool of implementations, to make copying of strands cheaper.
Ensured that kqueue support is enabled for BSD platforms (#3626).
Added a boost_ prefix to the extern "C" thread entry point function (#3809).
In getaddrinfo emulation, only check the socket type (SOCK_STREAM or SOCK_DGRAM) if a service name has been specified. This should allow the emulation to work with raw sockets.
Added a workaround for some broken Windows firewalls that make a socket appear bound to 0.0.0.0 when it is in fact bound to 127.0.0.1.
Applied a fix for reported excessive CPU usage under Solaris (#3670).
Added some support for platforms that use older compilers such as g++ 2.95 (#3743).

Added a new ping example to illustrate the use of ICMP sockets.
Changed the buffered*_stream<> templates to treat 0-byte reads and writes as no-ops, to comply with the documented type requirements for SyncReadStream, AsyncReadStream, SyncWriteStream and AsyncWriteStream.
Changed some instances of the throw keyword to boost::throw_exception() to allow Asio to be used when exception support is disabled. Note that the SSL wrappers still require exception support (#2754).
Made Asio compatible with the OpenSSL 1.0 beta (#3256).
Eliminated a redundant system call in the Solaris /dev/poll backend.
Fixed a bug in resizing of the bucket array in the internal hash maps (#3095).
Ensured correct propagation of the error code when a synchronous accept fails (#3216).
Ensured correct propagation of the error code when a synchronous read or write on a Windows HANDLE fails.
Fixed failures reported when _GLIBCXX_DEBUG is defined (#3098).
Fixed custom memory allocation support for timers (#3107).
Tidied up various warnings reported by g++ (#1341, #2618).
Various documentation improvements, including more obvious hyperlinks to function overloads, header file information, examples for the handler type requirements, and adding enum values to the index (#3157, #2620).

Implement automatic resizing of the bucket array in the internal hash maps. This is to improve performance for very large numbers of asynchronous operations and also to reduce memory usage for very small numbers. A new macro BOOST_ASIO_HASH_MAP_BUCKETS may be used to tweak the sizes used for the bucket arrays. (N.B. this feature introduced a bug which was fixed in Asio 1.4.3 / Boost 1.40.)
Add performance optimisation for the Windows IOCP backend for when no timers are used.
Prevent locale settings from affecting formatting of TCP and UDP endpoints (#2682).
Fix a memory leak that occurred when an asynchronous SSL operation's completion handler threw an exception (#2910).
Fix the implementation of io_control() so that it adheres to the documented type requirements for IoControlCommand (#2820).
Fix incompatibility between Asio and ncurses.h (#2156).
On Windows, specifically handle the case when an overlapped ReadFile call fails with ERROR_MORE_DATA. This enables a hack where a windows::stream_handle can be used with a message-oriented named pipe (#2936).
Fix system call wrappers to always clear the error on success, as POSIX allows successful system calls to modify errno (#2953).
Don't include termios.h if BOOST_ASIO_DISABLE_SERIAL_PORT is defined (#2917).
Cleaned up some more MSVC level 4 warnings (#2828).
Various documentation fixes (#2871).

Improved compatibility with some Windows firewall software.
Ensured arguments to windows::overlapped_ptr::complete() are correctly passed to the completion handler (#2614).
Fixed a link problem and multicast failure on QNX (#2504, #2530).
Fixed a compile error in SSL support on MinGW / g++ 3.4.5.
Drop back to using a pipe for notification if eventfd is not available at runtime on Linux (#2683).
Various minor bug and documentation fixes (#2534, #2541, #2607, #2617, #2619).

Enhanced CompletionCondition concept with the signature size_t CompletionCondition(error_code ec, size_t total), where the return value indicates the maximum number of bytes to be transferred on the next read or write operation. (The old CompletionCondition signature is still supported for backwards compatibility).
New windows::overlapped_ptr class to allow arbitrary overlapped I/O functions (such as TransmitFile) to be used with Asio.
On recent versions of Linux, an eventfd descriptor is now used (rather than a pipe) to interrupt a blocked select/epoll reactor.
Added const overloads of lowest_layer().
Synchronous read, write, accept and connect operations are now thread safe (meaning that it is now permitted to perform concurrent synchronous operations on an individual socket, if supported by the OS).
Reactor-based io_service implementations now use lazy initialisation to reduce the memory usage of an io_service object used only as a message queue.

Added support for serial ports.
Added support for UNIX domain sockets.
Added support for raw sockets and ICMP.
Added wrappers for POSIX stream-oriented file descriptors (excluding regular files).
Added wrappers for Windows stream-oriented HANDLEs such as named pipes (requires HANDLEs that work with I/O completion ports).
Added wrappers for Windows random-access HANDLEs such as files (requires HANDLEs that work with I/O completion ports).
Added support for reactor-style operations (i.e. they report readiness but perform no I/O) using a new null_buffers type.
Added an iterator type for bytewise traversal of buffer sequences.
Added new read_until() and async_read_until() overloads that take a user-defined function object for locating message boundaries.
Added an experimental two-lock queue (enabled by defining BOOST_ASIO_ENABLE_TWO_LOCK_QUEUE) that may provide better io_service scalability across many processors.
Various fixes, performance improvements, and more complete coverage of the custom memory allocation support.

Boost C++ Libraries

Revision History

Asio 1.4.6 / Boost 1.44

Asio 1.4.5 / Boost 1.43

Asio 1.4.4 / Boost 1.42

Asio 1.4.3 / Boost 1.40

Asio 1.4.2 / Boost 1.39

Asio 1.4.1 / Boost 1.38

Asio 1.4.0 / Boost 1.37

Asio 1.2.0 / Boost 1.36

Asio 1.0.0 / Boost 1.35