I find this is promising. Especially, with Visual Studio 2010, we’ve found completely revamped architecture for extending Visual Studio. On the other hand, Whole Tomato is a company, which had shown what customers really wanted out of Visual Studio. Their Visual Assist X plugin is an excellent piece of art. There are other famous guys who sells similar softwares like DevExpress. But I personally prefer VA, because it’s light weight and not leaving much confusions with cluttered interfaces like others.

Visual Studio Power Tools is another awesome free option to improve your productivity. But I believe Microsoft can do well with their IDEs. Ever since Visual Studio 2003, we’ve not gained anything better out of Microsoft IDEs. Almost 8 years, though Microsoft has introduced a bunch of technologies and language improvements especially for C#, the IDE remains a substandard for the world’s biggest developer community.

Visual Studio 2011 is a positive improvement where the art of search with regular expression integrated well with to find information quickly.

Read the full scoop here in Soma’s blog

Steve Jobs with iPad

I was so excited about watching the keynote video of iPad launch at Apple website. I am really excited to own on iPad. The multi-touch features and hardware itself is just amazing on the demo. Also I’d be happy to see the best iPhone applications on the same platform.

Despite the pros, I noticed about the cons of the new product. Don’t think that I am owning one iPad but I am writing this based on the impression from Key note and the technical specification. Also this post is fresh and I am not influenced by any tech pundit’s writing and guesses on the iPad.

[Updated 3.00 AM JST]

iPad still doesn’t support Adobe Flash. Irony is that iPad running Mac OS X  and can’t believe it doesn’t support flash. I can’t think of a “computer” which has no flash installed in it. (During the demo, the websites which has flash is displayed as unsupported. Check it out)

Steve Jobs already said in his presentation, the netbooks are cheap laptops. I agree that iPad has a gorgeous display. But has not good storage. I hope this is to promote the mobile me services of Apple. In my opinion more storage must get for a cheap price because this is not a phone.. Almost similar to a notebook or a high form of a netbook.

The device lacks a webcam. It even doesn’t contain a basic VGA webcam. What if I need to show up myself to my friends? Apple is seamless in their user experience while they restrict of make the user handicapped in terms of storage. Also Jobs dint mention about the iChat application.

When comes in to storage, the iPad basic capacity is 16 GB and they’re not running any iPhone OS, instead it’s powered with Mac OS X 10.5.8 or above. Which means that you’ve to spend few more room for the OS out of the basic 16/32/64 GB. Apple dint mention about any external storage which can be connected through the USB port. I hope it isn’t possible.

Again comes on the hardware specification. iPad is not really great. It has a great battery life around 10 hours and also it does have a great video accelerator. But still it’s 1 Ghz processor inside it. Most of the iPhone games are too reduced version of PC/Console version and limited in many ways. I think they must have more efficient processor specification. Even the so called “cheap laptops” has 1.6 Ghz processors.

The TV out capabilities are not built-in we’ve to buy a Dock to VGA adapter for enjoying the TV/Projector connectivity.

The device is capable of playing video up-to 720p. Still it’s not full HD. Also the resolution is 1024×768. It’s not really a big room. again I believe with the multi-touch panning and zooming of course the browsing experience will be good.

Also I doubt the gaming experience and convenience beside the accelero-meter. Also I don’t think to have a great typing experience with iPad. With iPhone one hand is enough for typing, but this case is different. For heavy typing we may have to depend on external keyboard.

Despite of all drawbacks, apple knows how sell a product and make business around it, that’s how they’re grown in these years. People loves spend and own for an Apple.

One more thing, Steve Jobs presentation was not really charming this time. The updates about how things are going on literally he took the head postion of “The biggest mobile company in the world” was not accepted well I guess. Also during the end, the presentation was slow and was out of sync. He doubted in many places. Never seen this before from Jobs. Let’s wait and see till we get one in hand.

As we all know, we can add the text input support for as many languages from the regional settings menu of Windows (you can see this in the control panel)

Even if you can add the language support, in fact they’re not get going well with a transliteration manner. If you type something, Malayalam it should appear as ??????. unfortunately Windows badly fails to do that.

If you’ve really enjoyed the Google transliteration service, they’re ready to provide the same text service as offline service through IME. No more copy paste from transliteration IME page your window.

Navigate to http://www.google.com/ime/transliteration/ and select your preferred language, finish download and install it.

Google Transliteration IME is currently available for 14 different languages – Arabic, Bengali, Farsi (Persian), Greek, Gujarati, Hindi, Kannada, Malayalam, Marathi, Nepali, Punjabi, Tamil, Telugu and Urdu.

Google Boasts it has

• Offline Support – No dependency with internet connection
• Easy Keyboard – Dictionary enabled keyboard to enter rare and complex words
• Word Completions – Dictionary based word completions for prefixes.
• Quick Search(you should expect this from Google) – Single click web search for highlighted word.
• Personalized Choices – Remember user corrections for personalized service.
• Customize suggestions page size, display font

More features can be found in this page

Okay here’s a simple and quick demonstration in my mother tongue.

1. Enable the language bar ( if it’s not enabled )

2. Select the language from language bar. You can see the Google Transliteration service on the right bottom of the screen (by default)

Note that This is a per Window Settings (like the normal IME operation). i.e if you’ve two notepads running and you selected Malayalam for one of them, the other will not be affected by this settings.

3. Now start typing

Now you’ve the basic education on transliteration services (if you’re a newbie). Now go ahead explore more. Chat, mail, or anything in your local language. Thanks Google for taking care of our mother tongue!!!

It’s quite simple to do that

unmount the USB device if it’s automatically mounted to the system.

Step 1

You can either use # umount <usb-drive> command or directly unplug using your nautilus file manager(windows shell equivalent)

Step 2

Image Writer is a small python executable script that detects your USB drive and writes the image to it. The advantage of using image writer is that it will not inadvertently overwrite your system hard drive. Download Image Writer. Navigate to the desired location where you kept the image writer and change its permission to execute.

# cd <directory with downloaded image-writer file>
# chmod a+x ./image-writer
# ./image-writer <image file>

Now you’re done!

There’s a alternative method using ‘dd’ which you can see in the following link. But it’s very risky. It may erase your whole system files if it’s not used carefully.

Source: moblin help

Mainly OutputDebugString function provided by Kernel32 DLL is used for “outputing” debug strings. There are other altenatives available like TRACE, ATLTRACE2 macros, afxDump function etc. and most of these are actually wrapping OutputDebugString API and provides flavored functionalities like formatting like printf string, dumping MFC objects etc. The most widely used are TRACE macros. There are some more alternatives for TRACE macros like TRACE0, TRACE1, TRACE2 (deprecated now). It’s nothing but impossing restrictions on the number of parameters.

Trace macros are supposed to work with debug build of the applciation and in release mode, the traces will not be available. If we approach OutputDebugString API, we will have to first format string using sprintf or CString::Format function and then pass to API. But this adds the burden of declaring temporary buffer/CString objects every time we call this function as follows

[sourcecode language='cpp']
CString csMessage;
csMessage.Format(_T(“My Data:%d”), nData );
OutputDebugString(csMessage).
[/sourcecode]

You will always have to repeat the above code wherever you need a debug trace. Ofcourse TRACE macro can be used as printf like function, but only in debug mode. So it’s better to write our own trace functions. 

The following function is  variadic function which can be used as printf function with format specifierss

[sourcecode language='cpp']
void M4DTrace( LPCTSTR lpctFormat, … )
{
static TCHAR szBuffer[1000];
va_list ArgList;
va_start( ArgList, lpctFormat );
_vstprintf_s( szBuffer, lpctFormat, ArgList );
va_end( ArgList );
OutputDebugString( szBuffer );
}
[/sourcecode]

Instead of _vsntprintf_s, you can use another formating function called wvsprintf
but I found it has some problems formatting float variables in the list. The above function can runs under both UNICODE and MBCS environment.
If you need to know under the hood of OutputDebugString, please check this article
Updated[2009-Apr-17) – updated formatting with _vstprintf_s instead of _vsntprintf_s

Here’s baker’s method (??) for checking whether a number is exact power of two or not.

b = ((n&(n-1))==0) ;

(NB: This code sets ‘b’ to TRUE if ‘n’ is an integer power of two – in this context, both zero and one are considered to be powers of two.)

This code actually works by changing the least significant ’1′ bit of ‘n’ to a ’0′. If ‘n’ is a power of two, it only has one ’1′ bit – and zeroing it leaves you with zero as the answer. Hence, the inner expression is also a cute trick…

If we would make it as a simple function it may appears as follows.

bool IsPowerOfTwo( int n )
{
    // Function returns true if the number if power of two
    return ((n&(n-1))==0) ;
}

The logic is simply straight forward which can be interpreted by using Windows Calculator. Check it yourself. The link contains some other cool tips as well.

Sidebar: Bakers also shared his interesting “Cruel Code List” as well J

Calling a CUDA function from your C/C++ file is very simple. It’s pretty straight forward as you call an extern function in C/C++. To start with, I believe you’ve added the CUDA program in your work space (or copy the program provided below and save as .cu file) and you could compile the file using CUDA compiler and finally the object files has been generated. Please check my previous post to know more about how to compile CUDA source in Visual Studio. CUDA follows C language constructs and rationales. The CUDA compiler will generate the object files which contains the functions and definitions of your CUDA program.

Let’s take a sample presented in a DDJ article CUDA, Supercomputing for the Masses: Part 2. The program increments the content of the array by one. Robb Farber has put an excellent effort to present CUDA in a simple manner in his high performance computing series on CUDA (Check DDJ). Please click on the link to know more about the program presented here.

[sourcecode language='cpp']
// incrementArray.cu
#include
#include
#include

void incrementArrayOnHost(float *a, int N)
{
int i;
for (i=0; i < N; i++) a[i] = a[i]+1.f;
}
__global__ void incrementArrayOnDevice(float *a, int N)
{
int idx = blockIdx.x*blockDim.x + threadIdx.x;
if (idx }

extern "C" void IncrementArray(void)
{
float *a_h, *b_h; // pointers to host memory
float *a_d; // pointer to device memory
int i, N = 10;
size_t size = N*sizeof(float);
// allocate arrays on host
a_h = (float *)malloc(size);
b_h = (float *)malloc(size);
// allocate array on device
cudaMalloc((void **) &a_d, size);
// initialization of host data
for (i=0; i // copy data from host to device
cudaMemcpy(a_d, a_h, sizeof(float)*N, cudaMemcpyHostToDevice);
// do calculation on host
incrementArrayOnHost(a_h, N);
// do calculation on device:
// Part 1 of 2. Compute execution configuration
int blockSize = 4;
int nBlocks = N/blockSize + (N%blockSize == 0?0:1);
// Part 2 of 2. Call incrementArrayOnDevice kernel
incrementArrayOnDevice <<< nBlocks, blockSize >>> (a_d, N);
// Retrieve result from device and store in b_h
cudaMemcpy(b_h, a_d, sizeof(float)*N, cudaMemcpyDeviceToHost);
// check results
for (i=0; i // cleanup
free(a_h); free(b_h); cudaFree(a_d);
}
[/sourcecode]

So the above program creates a simple CUDA program which increments the contents of each element in the array by one. What I changed from the original source code is, I made the main function as a new function which follows the “C” language rules.[that’s why I put extern “C” in front of the code. Even if you don’t add extern “C” it will work fine with your C++ compiler.
Instead of including the CUDA file by #include preprocessor, it’s better to define it as an external function by extern keyword.So your main program may appear as follows.

[sourcecode language='cpp']
// IntegrationWithCPP.cpp : Defines the entry point for the console application.
//

#include “stdafx.h”

// Forward declare the function
extern “C” void IncrementArray();

int _tmain(int argc, _TCHAR* argv[])
{
IncrementArray();
return 0;
}
[/sourcecode]

Finally link the program with cudart.lib cudartd.lib(debug) or cudart.lib(release) and enjoy your program!!!

That’s it. One thing I noticed is that, even if I define the main functions in CUDA file and my C++ file, I’m not getting any error from the linker. The linker gives error only if the main function in CUDA and C++ file having same prototype. Otherwise the version in the CUDA file will be called (from my experience so far).

The bin folder under your CUDA installation location (most probably C:\CUDA), you can see nvcc.exe which helps you to compile the CUDA program. If you give, nvcc my_cuda_filename.cu, the compiler will compile the source file and creates the executables (a.exe).

But in Windows world, most of the developers are much satisfied with the IDE Visual Studio. So may have to leave the world of command line compilation and source editing in favor of improving our productivity. If we can integrate the CUDA development to Visual Studio IDE, that’s pretty nice no? In one of my previous post, I said about enabling syntax highlighting for CUDA files under Visual Studio.

Now let’s check how we can support CUDA compilation under Visual Studio. CUDA compiler has a dependency with C++ compiler. It supports either Visual C++ 7.1 or 8.0. Currently it doesn’t support Visual C++ 9 (VS 2008).

Method 1 – Install CUDA Build Rule for Visual Studio 2005

There’s a painless method by installing a custom build rule for Visual Studio 2005 developed by JaredHoberock. A cool installer is available to do the necessary settings. When you add the “.cu” files to your application, it shows a dialog box to select the rule you installed. Press “OK” button.

Select CUDA Build Rule

You can control the per-file (.cu file) configuration for your application by selecting the properties of the file from your solution explorer. See the figure below.

Detailed Build Configuration under Wizard

The installer also adds new Project Type to create your new CUDA project which does the necessary settings for your application.

Wizard to create new CUDA Project

Finally you can put the required CUDA libraries (e.g CUDA Runtime library – cudart.lib) in Project->Properties->Linker->Input->Additional Dependency.

I think the installer won’t work for Visual Studio 2003. I think you can manually copy the rule file from $:\Program Files\Microsoft Visual Studio 8\VC\VCProjectDefaults\cuda.rules and specify this as the rule file for compilation. Anyway try it yourself.

Method 2 – Manually Configure by Custom Build Event

Without Visual Studio, we can use nvcc compiler for compiling the CUDA files with various command line parameters. So the same setup we can use with Visual Studio as well. One of the advantages is that, we can use various Visual Studio Specific variables to identify various file locations.

Custom Build

1. Select the CUDA source file from the solution explorer and take properties.

2.  Select “Custom Build Setup” from the tree

3.  You can select the active configuration from “Configuration” combo box.

4. Specify the following options under “Command Line”

“$(CUDA_BIN_PATH)\nvcc.exe” -ccbin “$(VCInstallDir)bin” -c -D_DEBUG -DWIN32 -D_CONSOLE -D_MBCS -Xcompiler /EHsc,/W3,/nologo,/Wp64,/Od,/Zi,/RTC1,/MTd -I”$(CUDA_INC_PATH)” -I./ -o $(ConfigurationName)\<your_cu_filename>.obj <your_cu_filename>.cu

The above configuration is to compile the source under debug configuration. For a release configuration, you will have to remove the symbol definition, _DEBUG (-D switch is to define symbols). Also the above command line ask to link with the static-debug version of C-Runtime library by specifying /MTd option. In the case of release build you will have to modify it to /MD or /MT. Please check the various C-Runtime versions from MSDN and apply accordingly. Thus a sample command line for release version may look as follows. 

“$(CUDA_BIN_PATH)\nvcc.exe” -ccbin “$(VCInstallDir)bin” -c -DWIN32 -D_CONSOLE -D_MBCS -Xcompiler /EHsc,/W3,/nologo,/Wp64,/Od,/Zi,/RTC1,/MD -I”$(CUDA_INC_PATH)” -I./ -o $(ConfigurationName)\<your_cu_filename>.obj <your_cu_filename>.cu

If you need to add Device Emulation option, you add -deviceemu switch in the command line. Thus you the compiler will generate code for GPGPU Emulation library. You can understand more about each switches from MSDN itself. The information about the other variables used has been specified at the end of this post.

5. You can specify your own description for the custom build event under “Description” text box. (See the figure)

6. Finally you have to specify the output file name under “Outputs”

$(ConfigurationName)\<your_cu_filename>.obj

7. If you  have included any CUDA files (probably will be having extension .cu or .cuh), you can specify it in the “Additional Dependencies option

In the command line string, we’ve used some visual studio specific build macros. You can see the entire list of Visual Studio Build Macros in MSDN.

8. Finally build your project and now see the output of CUDA compilation in your output Window.

Adding a new build configuration

Sometimes you have to build your file with CUDA emulation for many debugging purpose.  Please check MSDN to know more about adding build configuration.

I’ll explain how to call a CUDA Program from a C++ file in the next post. Thanks for your patience. I’m a newbie in CUDA. If you’ve better ideas and suggestions, please share with me through your comments.

In this post, I’m talking about some internals of Windows Shutdown in the context of applications.

When the user or an application initiates shutdown request through ExitWindowsEx function, the Csrss.exe will be initiating the shutdown operation by sending a window message to the hidden window owned by Winlogon process. The subsystem process Csrss.exe contains handles, Console (text) windows, creation and deletion of processes and threads and other various supports like ExitWindowEx etc…

The Winlogon process calls ExitWindowsEx function with some internal flags to continue the shutdown based on the security access rights of the currently-logged in user. Since the ExitWindowEx call has been made again, it falls back in the hand of Csrss.exe.

Csrss sends the WM_QUERYENDSESSION message to each thread in the process that has a Windows message loop. This message is like warning from the system that, the application has to respond for the shutdown operation. The shutdown can be preceded when the thread returns TRUE. If the thread returns FALSE, in most cases, the shutdown operation will be cancelled. The shutdown should be cancelled only for the valid reasons like CD burning, live recording etc…

Windows Vista supports more interactive shutdown(When the screen like left appears and I wondered when try to shutdown while the office applications are running. Now got the nuts and bolts of it ). One or many applications can cancel the shutdown operation under windows XP. In windows vista, if either of the application cancels shutdown operation, windows shows the list of currently running application and also the blocking application on the top of the window. If the user wants to shut his computer down, he can forcefully do that by clicking on the “Shut down now” button(red button in the figure). In this case windows sends WM_QUERYENDSESSION again with ENDSESSION_FORCEFULSHUTDOWN flag. If an application responds FALSE, Windows will continue shutdown instead of canceling it.

Windows Vista provides a facility to pro-actively describe about the reason for cancelling the shutdown. There are three new APIs at our disposal to manage shutdown cancellation string.

[sourcecode language='cpp']
BOOL ShutdownBlockReasonCreate(HWND hWnd, LPCWSTR pwszReason);
BOOL ShutdownBlockReasonDestroy(HWND hWnd);
BOOL ShutdownBlockReasonQuery(HWND hWnd, LPWSTR pwszBuff, DWORD *pcchBuff);
[/sourcecode]

The above functions are used to create, destroy and query the cancellation string for the window. The best time to create the string is at WM_QUERYENDSESSION function and destroys it once the application finished using it. (See the sample below for the usage)

Once the Query end session function returns true or managed to get out from the above described scenarios, Csrss then sends the WM_ENDSESSION Windows message to the thread to request it to exit. The application will get 5 second as time out as default (it’s defined in HKCU\Control Panel\Desktop\HungAppTimeout). If an application times out responding to WM_QUERYENDSESSION or WM_ENDSESSION, Windows will terminate it.

The behavior of the application time out is slightly different in Windows Vista and XP as we see in the picture below. Please check MSDN (I don’t want to copy paste it here) to get the detailed table.

If the thread doesn’t exit before the timeout, Csrss displays the hung-program dialog box (End Now). You can disable this dialog box by changing the registry value HKCU\Control Panel\Desktop\AutoEndTasks to 1. This dialog box indicates that a program isn’t shutting down in a timely manner and gives the user a choice of either killing the process or aborting the shutdown. There is no timeout on this dialog box, which means that a shutdown request could wait forever at this point.

Once all the threads that own windows in the process have exited, Csrss terminates the process and goes on to the next process in the interactive session.

OK Now you’re capable of handling the shutdown message for your application. Here’s a sample snippet for doing the same (MFC)

[sourcecode language='cpp']
/* Map the following functions manually in your application (Win32 style)
*/

BEGIN_MESSAGE_MAP(CShutDownTestDlg, CDialog)
ON_MESSAGE( WM_QUERYENDSESSION, QueryEndSession )
ON_MESSAGE( WM_ENDSESSION, EndSession )
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

LRESULT CShutDownTestDlg::QueryEndSession(WPARAM,LPARAM)
{
// Block shut down
ShutdownBlockReasonCreate(m_hWnd, L”TV Show being recorded” );
return FALSE;
// return TRUE; // continue shutdown
}

LRESULT CShutDownTestDlg::EndSession(WPARAM,LPARAM)
{
// Destroy the shutdown string used earlier
ShutdownBlockReasonDestroy(m_hWnd);
return TRUE;
}
[/sourcecode]

Here’s the pure MFC way to do the same

[sourcecode language='cpp']
/* Add the function using class wizard or through property window (VS2003 or above)
*/

BEGIN_MESSAGE_MAP(CShutDownTestDlg, CDialog)
ON_WM_QUERYENDSESSION()
ON_WM_ENDSESSION()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BOOL CShutDownTestDlg::OnQueryEndSession()
{
// Block shut down
ShutdownBlockReasonCreate(m_hWnd, L”TV Show being recorded” );
return FALSE;

}

void CShutDownTestDlg::OnEndSession(BOOL bEnding)
{
// Destroy the shutdown string used earlier
ShutdownBlockReasonDestroy(m_hWnd);
CDialog::OnEndSession(bEnding);
}
[/sourcecode]

Hope you enjoyed this lengthy post. Thanks for MSDN articleand Mark Russinovich for his book Windows Internals. Those were the light for my path.

Most of us have used WaitForSingleObject and WaitForMultipleObjects in our code. Well, what we can do more with MsgWaitForMultipleObjects (there’s no API called MsgWaitForSingleObject. You will understand the reason soon).

MsgWaitForMultipleObjects wait for a wait-able kernal object and for the input messages in the current thread.

You may find it very useful in some situations. What if we can do the window painting, process the timer message even the UI thread in the wait state. Pretty cool no? Even I don’t know the under the hood of “Add Remove Programs” application, I believe that the application waits till the current un-install program finishes its execution and during this time, it’s even allows proper painting of its windows components.

The function takes the following shape.

[sourcecode language='cpp']
DWORD WINAPI MsgWaitForMultipleObjects(
__in DWORD nCount,
__in const HANDLE *pHandles,
__in BOOL bWaitAll,
__in DWORD dwMilliseconds,
__in DWORD dwWakeMask
);
[/sourcecode]

You can get detailed information and various parameters from the MSDN documentation of the API. Here I’m describing only the important ones.

You can pass multiple wait-able handles as an array to the function by specifying the size of the array. The maximum number of objects is MAXIMUM_WAIT_OBJECTS – 1 because the last wait object is used to indicate the availability of message by getting out from the wait function. If the function returned WAIT_OBJECT_0 + nCount, then it indicates that the new input of the type specified in dwWakeMask is arrived. You can get detailed information on the return value from MSDN documentation.

The next important parameter is dwWakMask. It indicates the possible type of messages we wish to wait upon.

Read further after checking the code OK? I want to convey few caveats of this API. It will be too early to describe here. Here’s the sample demonstration of the API

[sourcecode language='cpp']
HANDLE hQuit = 0; // Mutex handle
// Message definition
DWORD DO_PROCESSING_MSG = 5555;

DWORD WINAPI ThreadFxn( LPVOID )
{
MSG msg;
while( true )
{
// Wait for mutex and all input events
DWORD dwResult = MsgWaitForMultipleObjects( 1,
&hQuit,
FALSE,
INFINITE,
QS_ALLEVENTS );

// if message has been received
if( dwResult == WAIT_OBJECT_0+1 )
{
// Check if message arrived or not
if(PeekMessage(&msg, (HWND)-1, 0, 0, PM_REMOVE))
{
// Translate and dispatch message
TranslateMessage(&msg);
DispatchMessage(&msg);
}
printf (” \n New Message Receieved ” );
}
else // it’s time to quit
{
printf( “\nbye bye” );
break;
}
}
return 0;
}

int _tmain(int argc, TCHAR* argv[])
{
int nRetCode = 0;
// Create Mutex
hQuit = CreateMutex( 0, TRUE, 0 );

DWORD dwTid = 0;
// Create new thread
HANDLE hThread = CreateThread(0,0,ThreadFxn,0,0,&dwTid);

// Post some message
for ( int i = 0 ; i < 10; i ++ )
{
// Post message to thread's queue
PostThreadMessage( dwTid, DO_PROCESSING_MSG, 0, 0 );
Sleep( 500 );
}

// Signal the mutex to quit
ReleaseMutex( hQuit );
// Wait till the thread exits
WaitForSingleObject( hThread,INFINITE);
CloseHandle( hQuit );
return nRetCode;
}
[/sourcecode]

The tricky bWaitAll parameter.

If you check the bWaitAll parameter’s document in MSDN, you can find it is described same as WaitForMultiplObjects API. In the sample code above, we’re waiting for one kernel object and the thread messages we’re interested.

What happens if we wait as follows ?

[sourcecode language='cpp']
DWORD dwResult = MsgWaitForMultipleObjects( 1,
&hQuit,
TRUE,
INFINITE,
QS_ALLEVENTS );
[/sourcecode]

We’re passing bWaitAll parameter as true instead of FALSE. Which means that the function returns all the objects we’re waiting upon should be signaled. Here we’re passing only kernel object and even if you call “ReleaseMutex”, the thread will not be signaled until it receives a message in the thread’s queue. i.e the function actually waits for kernel objects + one more message in the thread’s queue.

Raymond chen explains about another caveat with MsgWaitForMultipleObjects and the queue state in his blog. I will explain the issue here in short.

PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) returns TRUE indicating that there is a message. Instead of processing the message, you ignore it and call MsgWaitForMultipleObjects.

This wait will not return immediately, even though there is a message in the queue. That’s because the call to PeekMessage told you that a message was ready, and you willfully ignored it. The MsgWaitForMultipleObjects message tells you only when there are new messages; any message that you already knew about doesn’t count. The MsgWaitForMultipleObjectsEx function lets you pass the MWMO_INPUTAVAILABLE flag to indicate that it should check for previously-ignored input. Seems It’s enough read more details from Raymond’s blog.

Sidebar: The windows CE documentation saying it’s possible to wait for CriticalSection object with MsgWaitForMultipleObjects. I believe that could be their typo or something. But I never succeeds to call this API with Critical Section objects. Please let me know if someone could use it with Critical Section objects.