C++ async OutputDebugString

Question

With the new std::async in c++11, I thought I might go about trying to implement an async version of OutputDebugString to free me of some of the performance downs that result from my usual heavy printing of every little detail through the usual OutputDebugString function.

So here is my original sync OutputDebugString implementation(which works):

static void OutputDebugStringN(const char *format, ...)
{
    char outstring[256];
    memset(outstring, 0, sizeof(outstring));

    try
    {
        va_list args = {0};
        va_start(args, format); //args = (va_list) (&format+1);

        vsprintf_s(outstring, format, args);

        va_end(args);

        OutputDebugString(outstring);
    }
    catch (...) //most likely reference val arg error (va_list doesn't support ref args)
    {
        OutputDebugString("[OutputDebugStringN] Something went wrong\n");
    }
}

and the following my very naiive attempt at an async version(which doesn't work):

static void OutputDebugStringN(const char *format, ...)
{
    auto future = std::async([]{
        char outstring[256];
        memset(outstring, 0, sizeof(outstring));
        try
        {
            va_list args = {0};
            va_start(args, format); //args = (va_list) (&format+1);

            vsprintf_s(outstring, format, args);

            va_end(args);

            OutputDebugString(outstring);
        }
        catch (...) //most likely reference val arg error (va_list doesn't support ref args)
        {
            OutputDebugString("[OutputDebugStringN] Something went wrong\n");
        }
    }); 
}

And since the above doesn't work I'm now at the point where I'm starting to think that async calling OutputDebugStringN might be better than trying to launch an async job inside the function itself as so (which works, but cumbersome):

auto dstring = std::async([]{ OutputDebugStringN("[NovelScript::ParseTokens] searched bookmark: \"%s\" does not exist\n", bookmark.c_str());} );

So here are two questions I'd like to ask:

1. How should I be going about implementing an async version of OutputDebugString?
2. Should I even be trying to implement an async version of OutputDebugString?

Criticism on the above code and any other comments are also much welcome.

Answer 1

I think you should have a queue for your messages instead of starting a thread with each call to your function, that way your messages will be output clean and in the right order.

So your function e.g. OutputDebugStringN(const char *format, ... ) would create the message string and then queue the string that a seperate printout thread reads from. That thread would call OutputDebugString.

Here's an example - not complete though, no error handling and print_from_queue should be modified to run until some termination condition and be a bit more friendly to the CPU.

std::mutex g_m;
std::deque<std::string> que;
std::atomic<bool> endcond = false;

void queue(std::string msg)
{
  std::lock_guard<mutex> _(g_m);
  que.push_back(msg);
}

void print_from_queue()
{
  while ( !endcond )
  {
    if ( que.size() )
    {
      std::lock_guard<mutex> _(g_m);
      std::string msg = que.front();
      que.pop_front();
      OutputDebugStringA(msg.c_str());
    }
  }
}

int debugf( const char *format,... )
{
  std::vector<char> line(256);
  va_list args;
  va_start( args, format );
  int len = vsprintf_s( &line[0], line.size(), format, args );
  va_end( args );
  queue( &line[0] );
  return len;
}

int _tmain(int argc, _TCHAR* argv[])
{
  auto thr = std::async( std::launch::async, print_from_queue );
  debugf("message1");
  debugf("message2");
...

Answer 2

In my opinion, debugging should be synchronous, and not asynchronous. Would you appreciate if debugger gives you exception seconds after it occurred? Would you appreciate a log-file having stale data of your program status, after your program crashed (since you made file-writing asnyc)?

Anyhow, you went ahead and made the debug-output as asynchronous. What purpose does it solve, other than just dumping data to debug-window, you know it is not recent, it doesn't reflect your/user or program's actions, it is all stale! You absolutely cannot rely on it.

Answer 3

criticism of the code above and of the C++ async function: :p

The return value of std::async is an object of type std::future. The destructor of std::future created by std::async waits until the task has been executed. So when you do:

auto future = std::async(...

or

auto dstring = std::async([]{

it creates an object of type std::future, and when you leave scope of your OutputDebugStringN, it calls the destructor of std::future, which blocks until the task gets executed.

In my opinion, this is a flaw with C++. It's somewhat idiotic (hopefully this doesn't offend anyone :p), and it totally defeats the purpose of async. In order to get the behavior that most people expect (apparently, you expected it), you have to keep a list of std::future objects, and then spend effort (and processing time) figuring out the right time to destroy individual std::future objects in your list. This is the answer to question #1 in the OP. For #2, I think you should not use std::async for this purpose on a per debug message basis. I think it creates more problems than it solves.

I don't know that there is an elegant way around this. Maybe someone else can chime in.

As far as how I would go about implementing an asynchronous version of OutputDebugString, I would just create a producer-consumer queue of strings. There have been tons of questions asked about that, and you can google producer-consumer queue for details. The producer is your main thread that is emitting the message. The consumer is a thread (or several threads) that pick out elements from the queue and calling Window's OutputDebugString.

EDIT: in case I offended any async enthusiasts, I would like to add that std::async is useful for doing parallel computation much like using GPU. I suspect it was designed for exploitation of parallel hardware. For example:

      // merge sort
      {
           auto left =  std::async(.....);  // merge_sort left
           auto right =  std::async(.....);  // merge_sort right
      }

      merge

in this way, both left and right have to be sorted before we merge. if not, wait until they're both sorted, but it allows for the opportunity to process both left and right in parallel.

this should look very familiar if you've done CUDA or any GPGPU coding...