Minutes, WG21/SG4 Meeting 8 May 2012 Redmond, Washington, USA

Monday 8 May 2012

Meeting attendees:

• Kyle Kloepper (Chair)
• Alex Fabijanic
• Neal Meyer
• Niklas Gustafsson
• Ville Voutilainen
• William Chan

Agenda

• Discussion of Papers (AM Session)
  • POCO - Alex Fabijanic
  • Boost ASIO - Kyle Kloepper
  • Casablanca - Niklas Gustafsson
  • libcppnet URI - Kyle Kloepper

Disclaimer: These minutes were recorded by a human all errors are those of the author - Neal

Alex Faijanic POCO Network Programming

http://wiki.edg.com/twiki/pub/PublicRepository/SG4Docs2012/POCO.Net.pdf

• DNS:hostByName() is that the blocking Version?
  • Alex - Yes - this is threads with blocking.
• Niklas - Is there any C++11 support
  • Alex - Not currently 2.0 (early next year) will be add full C++11 Suport
• Niklas - ServerSocket is what you listen on?
  • Alex - Yes
• WebSockets are sockets that enable HTTP connections to fallback to underlying TCP?
• SecureStreamSockets and SecureSeverSocket simple overrides of StreamSocket and ServerSocket to enable secure versions
• Kyle - select() and poll() how are these done on Windows
  • Its a simple ifdef to use select(), poll() and epoll()
• Kyle - Will using POSIX style code be efficient when running on Windows -
  • Niklas - Some library was 2-3x slower running when running posix layers on top of WindowsAPIs.
  • Ville - We had a similar discussion when threads were discussed for C++11, but it was less then a stellar feat for Windows.
• Kyle/Niklas - WebSockets are just a way to implement the CometHack
• Neal - How do Delegates relate to std::bind/ std::function type syntax
  • Ville - Delegates allow for chaining of Delegates where functions don't.
• Kyle - Are Delegates similar to .then in Async functions?
  • Niklas - Delegates are essentially implementation of the Observer pattern
• Neal - How are the multiple Delegates called in a multi-threaded environment?
  • Alex - There are policies that allow you to modify how those are called.
• William - Where are those specified?
  • Alex - Offline we can discuss this later.
• Kyle - HTTPServer - Who are the users of this?
  • Alex - This is obviously not going to work for the Amazon's and Google's of the world, but in smaller instances embedded world or smaller Linux distributions.
  • Alex - I've tested in comparison to Apache and they generally performed similar when throwing a lot of connections at it.
• Niklas - FTPClient, can you enumerate directories and file lists
  • Alex - Yes the FTP client would have functions for all of the standard FTP behaviors
• Niklas - SMTPClient - Multiformat messages ?
  • Alex - Yes
  • Ville - I've written a client with POCO that worked well with Google Mail
• Niklas - Microsoft is focussing on Cloud Programming and we want to make C++ relevant in that space. Something like POCO that has a good user experience is ideal, but the lack of Async on the client stopped us from being able to use it. From the usability side I think it is great
• Niklas - Do you do your own HTTP parsing
  • Alex - Yes
• Ville - What is the way forward with POCO and C++17?
  • Alex - We would like to see some of it in the standard, but it would be hard to add Net without the Foundation parts.
  • Ville - Do you have plans to isolate the Foundation from Net for proposals to the Standard
  • Alex - Yes depending on interest from the committee
  • Niklas - When we get to the scope discussion I think it is important to have unifying types that can be shared across libraries.
  • Ville - Even if we fail to standardize networking, standardizing on vocabulary types would be useful.

Kyle Kloepper for Chris Kholhoff - Boost ASIO

http://wiki.edg.com/twiki/pub/PublicRepository/SG4Docs2012/d3388.pdf

• William - Does the async_connect have to wait or can it run immediately? For things like domain sockets where connects could happen immediately.
  • Kyle - No
• Ville - So io_service.run() is what would be invoked by the user?
  • Kyle - Yes,
• Ville - Is the io_service similar to the executor?
  • Kyle - Yes.
  • Niklas - But it is not abstract where you could write your own.
• Niklas - enable_share_from_this<>, is that a standard thing or a boost thing?
  • Ville - It's a standard thing.
• William - Are there mechanisms in ASIO to deal with OS's that are blocking like GetAddrInfo()?
  • Kyle - Don't really know
  • Alex - I've read through the docs and they do a good job relying on Completion Ports and other Windows facilitates.

Discussion

• Niklas - When I talked to Chris about Async - he had concerns that a std::future based approach is not the best way to be efficient. Things like async_transfer() need to be included, because these are extremely difficult to implement. When multiple things like this were being done at the same time, it gets very complicated for users very quickly.
• William - I was actually interested in how the memory was being passed, it seems like the memory is always owned by the caller is that right? I'm not sure exactly, but I'd want to be careful with where memory is allocated and how cancels would be handled.
• Niklas - ASIO doesn't really support cancellation.

Break

Niklas Gustafsson - Casablanca

• Ville - HTTPWorker - So this works with only 1-5 handlers?
  • Niklas - yes this is the simple version.
• Neal - You mentioned that the boost::asio.io_service.run() isn't ideal for Win8 programming, but you are obviously using an io_service like object to run your lambda's. Where is that io_service?
  • Niklas - The Windows Thread pool is the io_service.
• Ville - How much has been of this has released?
  • Niklas - All of what I'm showing is up on MSDN Labs.
• Alex - You said this is based on Windows Thread Pool.
  • Niklas - The Windows Thread Pool knows how to do Asynchronous already.
• Niklas - The point here is that we don't necessarily need to have the HTML standardization effort tied to a socket layer proposal. And if they are then on Windows might not be able to use them.

• Kyle - If we were to standardize and HTTP interface how would we accomodate the browser authors and casual users as well
  • William - I'm not sure how much of this we would actually want to standardize. Either we do a Java standardize everything type approach, which I don't think is want C++ has tended to do.
  • Niklas - I think the standardization of the types for compose-ability is the most important part.

Kyle Kloepper for Glyn Matthews & Dean Michael Berris - URI proposal

http://wiki.edg.com/twiki/pub/PublicRepository/SG4Docs2012/AProposaltotheCSG4WorkingGroupforaURILibrary.pdf

• Niklas - What are the parameters for from_parts().
  • Kyle - Not sure the full doc is in the paper
  • Niklas - We wanted some additional features which is why we made certain design decisions with our uri_builder
• William - Is this cross platform? If so how do they deal with different encodings?
  • Kyle - Appears to use boost::file_system like semantics and std::codecvt.

Discussion

• Niklas - The tokenizer part of it is important access to parts of the path and query
• Ville - Seems to be missing way to accessing query parameters
• William - One problem with standardizing this is there are lots of different compatibility issues with URI's.
• Niklas - If we right something that is RFC compliant may not work in practice.
• Alex - Do you have an example?
  • Escape control characters

Kyle Kloepper for Christopher Kohlhoff - Urdl

http://wiki.edg.com/twiki/pub/PublicRepository/SG4Docs2012/d3389.pdf

• Niklas - Again Asyncrounisty is dependent on the executor

Break for Lunch

Scope discussion

• Kyle - What is the scope or where we should start?
  • Group generate the following list of terms (Sizing estimates)
    • Sockets (L)
    • URI (S)
    • IP Address (S)
    • HTTP (L)
    • General Asynchronous IO (L)
    • Synchronous IO Streams ()
    • Asyncronous IO Streams ()
    • Asyncronous Streambuf ()
    • Resolvers (DNS, etc.) (S)
    • ICMP (S)
    • Packet Capture (S)
    • SSL (M)
    • Out-of-scope from SG4
      • JSON (S-M)
      • XML (L)
      • Compression
      • binary_stream
  • Straw Poll - Should Sockets be part of a future standard?
    • Yes - 7, No - 0
  • Straw Poll - In favor of annual TS?
    • Yes - 6, No - 0, Abstain - 1

• Kyle - How do we get from nothing to less embarrassing for C++17? We expect the door to close for new features between 2014-2015. The following guideline framework was proposed and drivers volunteered. Straw man timeline proposal.
  • 2012 Portland - URI (Nikolas), IPAddress (Alex), Network byte order (Kyle)
  • 2013 - Async Model (Nikolas), HTTP, Resolvers
  • 2014 - Sockets, Async Streams
  • 2015 - SSL, ICMP

• Kyle - What does having Sockets mean?
  • Alex - TCP, UDP, Stream Interface, Multi-cast, Socket Options
  • hardware address, ifconfig/ net config

• Kyle - AsyncStream is composed of
  • buffers, iostream
  • stream_buf for network * async * async
  • Discussion devolved to where wether or not async streams should or should not mimic iostreams.

• Owners of the three targeted features, send out request for interest to the reflector, and then review