Using Boost io_service to synchronize with user theread

When writing GUI application using MFC, you can encounter a situation that ask you to call some GUI method in a non-GUI thread. This can happens when there are more than 1 threads running - quite common case in nowaday. When application call methods like GetAfxMainWnd() in non-GUI thread, the application crashes. AfxGetMainWnd() stores information at thread local storage which can't be access in the non-GUI thread. Refer below code. Foo runs a non-GUI thread which call a GUI-thread only method that can crash an application.

	class Foo
	{
	public:
	static void Run()
	{
	boost::thread nonGUI( FooThread );
	nonGUI.join();
	}
	static void FooThread()
	{
	Foo foo;
	for(;;)
	{
	foo.MethodInNonUserThread();
	}
	}
	void MethodInNonUserThread()
	{
	PrepareDrawing();
	MethodThatHasToBeInUserThread(); // CRASH HERE due to AfxGetMainWnd()
	}
	void MethodThatHasToBeInUserThread()
	{
	CMainFrame* mainFrame = (CMainFrame*)AfxGetMainWnd();
	mainFrame->DrawFoo();
	}
	};

view raw Foo.cpp hosted with ❤ by GitHub

To get over this problem, you have to make a GUI thread to call a method for the non-GUI thread. If we just put the method on the GUI class holding GUI thread - CMainFrame in above, it makes the GUI class to be dependant on a completely separate class. It is a bad design. And also it is not possible to know all the different methods that will comes up to be called in GUI thread. If we add methods on the GUI-thread whenever a new stuff comes up, the code is constantly changing. Refer below code snippet that demonstart this scenario. In here, the exact implementation detail of synchronization is not shown .e.g SignalGUI(), WaitForGUIToFinish(), IsGUISignaled(). It can be implemented with semaphore and list structure.

	class Foo
	{
	void MethodInNonUserThread()
	{
	PrepareDrawing();
	SignalGUI();
	WaitForGUIToFinish();
	}
	void MethodThatHasToBeInUserThread()
	{
	CMainFrame* mainFrame = (CMainFrame*)AfxGetMainWnd();
	mainFrame->DrawFoo();
	}
	};
	class CMainFrame
	{
	void Timer()
	{
	if( m_Foo->IsGUISignaled() )
	{
	m_Foo->MethodThatHasToBeInUserThread();
	m_Foo->SignalFoo();
	}
	if( m_Bar->IsGUISignaled() )
	{
	m_Bar->MethodThatHasToBeInUserThread();
	m_Bar->SignalBar();
	}
	}
	};

view raw ManualSync.cpp hosted with ❤ by GitHub

With boost IOService, this situation can be elegantly solved with good separation between GUI and non-GUI class. Controller class has io_service and it acts like a bridge between GUI and non-GUI class. The non-GUI class can Post() it's own method that has to run in a GUI thread. The GUI class can just call Controller's Poll() method and that will call non-GUI's posted method subsequently

	class Foo
	{
	struct UserData
	{
	HANDLE EventToFinish;
	};
	// run in non-GUI thread
	void MethodInNonUserThread()
	{
	PrepareDrawing();
	UserData data;
	data.EventToFinish = CreateEvent( NULL, FALSE, FALSE, NULL );
	m_Controller->Post( MethodThatHasToBeInUserThread, &data );
	WaitForSingleObject( t.EventToFinish, INFINITE );
	}
	// run in GUI thread i.e. CMainFrame::Timer() call
	static void MethodThatHasToBeInUserThread( void* arg )
	{
	UserData* data = static_cast<UserData*>(arg);
	CMainFrame* mainFrame = (CMainFrame*)AfxGetMainWnd();
	mainFrame->DrawFoo();
	SetEvent( data->EventToFinish );
	}
	};
	class Controller
	{
	boost::asio::io_service m_Service;
	void Post( CALLBACK_FN_USER_THREAD fn, void *user )
	{
	m_Service.dispatch( boost::bind(fn, user) );
	}
	void Poll()
	{
	m_Service.poll();
	}
	};
	class CMainFrame
	{
	void Timer()
	{
	m_Controller->Poll();
	}
	};

view raw UsingIOService.cpp hosted with ❤ by GitHub

Above Controller() provides a good isolation between two different entity and also reusable as it doesn't depend how the GUI and non-GUI class are made.

Using MSBUILD

Using MSBUILD and making a build process has advantage on other building tools - e.g. nants ... - and that is IDE. When project file is loaded in Visudal Studio IDE and when project is compiled in build process, there is no difference. So just write code and test it in the IDE is enough to run build process.

But to be consistent on the build result across number of project, it should have a common configuration setting that applies to all the project. This can be easily done by just taking out common part of project and import it in the project configuration. Refer below code snippet. There is Import which asks for BuildUnitTest.Default.props. This file can contains all the common setting across all the unit test that is based on the boot unit test framework.

	<?xml version="1.0" encoding="utf-8"?>
	<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
	<ItemGroup Label="ProjectConfigurations">
	<ProjectConfiguration Include="Debug|Win32">
	<Configuration>Debug</Configuration>
	<Platform>Win32</Platform>
	</ProjectConfiguration>
	<ProjectConfiguration Include="Release|Win32">
	<Configuration>Release</Configuration>
	<Platform>Win32</Platform>
	</ProjectConfiguration>
	</ItemGroup>
	<PropertyGroup Label="Globals">
	<ProjectGuid>{YOUR_GUID_GO_HERE}</ProjectGuid>
	<Keyword>Win32Proj</Keyword>
	<RootNamespace>YOUR_PROJECT_NAMESPACE_GOES_HERE</RootNamespace>
	<ProjectName>YOUR_PROJECT_NAME_GOES_HERE</ProjectName>
	</PropertyGroup>
	<PropertyGroup>
	<SRC_ROOT>..\..</SRC_ROOT> <!-- example of a custom property -->
	<UseOfAtl>Static</UseOfAtl>
	</PropertyGroup>
	<Import Project="$(SRC_ROOT)\Build\BoostUnitTest.Default.props" />
	<ItemDefinitionGroup> <!-- project specific setting -->
	<ClCompile>
	<AdditionalIncludeDirectories>..\include;..\SequenceControl;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
	<PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
	</ClCompile>
	<Link>
	<AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
	</Link>
	</ItemDefinitionGroup>
	<!-- your project file goes here -->
	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
	<ImportGroup Label="ExtensionTargets">
	</ImportGroup>
	</Project>

view raw MSBuild Project File Sample hosted with ❤ by GitHub

Now the BuildUnitTest.Default.props can be looked like below. Note setting like OutDir and IntDir. By using this common project file, all the project can emit the generated output file to the OutDir which is consitently named location and all the intermediate file can go to the consitently named IntDir. And note the Debug and Release usage to make consistent setting applying to all the project that import this file.

	<?xml version="1.0" encoding="utf-8"?>
	<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
	<PropertyGroup>
	<ConfigurationType>Application</ConfigurationType>
	<CharacterSet>MultiByte</CharacterSet>
	<PlatformToolset>v100</PlatformToolset>
	</PropertyGroup>
	<PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
	<UseDebugLibraries>true</UseDebugLibraries>
	<WholeProgramOptimization>false</WholeProgramOptimization>
	</PropertyGroup>
	<PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
	<UseDebugLibraries>false</UseDebugLibraries>
	<WholeProgramOptimization>true</WholeProgramOptimization>
	</PropertyGroup>
	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
	<ImportGroup Label="ExtensionSettings"/>
	<ImportGroup Label="PropertySheets">
	<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
	</ImportGroup>
	<PropertyGroup Label="UserMacros" />
	<PropertyGroup>
	<OutDir>..\bin\$(Configuration)\</OutDir>
	<IntDir>..\Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
	<IgnoreImportLibrary>false</IgnoreImportLibrary>
	</PropertyGroup>
	<PropertyGroup Condition="'$(Configuration)'=='Debug'">
	<LinkIncremental>true</LinkIncremental>
	</PropertyGroup>
	<PropertyGroup Condition="'$(Configuration)'=='Release'">
	<LinkIncremental>false</LinkIncremental>
	</PropertyGroup>
	<ItemDefinitionGroup>
	<ClCompile>
	<PrecompiledHeader />
	<WarningLevel>Level3</WarningLevel>
	<PreprocessorDefinitions>WIN32;_WINDOWS;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions)</PreprocessorDefinitions>
	<AdditionalIncludeDirectories>$(SRC_ROOT)\3rdParty\boost_1_53;$(SRC_ROOT);$(SRC_ROOT)\Common;..\bin\$(Configuration)\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
	<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
	<ExceptionHandling>Async</ExceptionHandling>
	</ClCompile>
	<Link>
	<AdditionalDependencies>comctl32.lib;%(AdditionalDependencies)</AdditionalDependencies>
	<AdditionalLibraryDirectories>$(SRC_ROOT)\3rdParty\boost_1_53\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
	<GenerateDebugInformation>true</GenerateDebugInformation>
	<SubSystem>Console</SubSystem>
	</Link>
	</ItemDefinitionGroup>
	<ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
	<Link>
	<TargetMachine>MachineX86</TargetMachine>
	</Link>
	</ItemDefinitionGroup>
	<ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
	<ClCompile>
	<Optimization>Disabled</Optimization>
	<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
	<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
	</ClCompile>
	<Link>
	</Link>
	</ItemDefinitionGroup>
	<ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
	<ClCompile>
	<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
	<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
	</ClCompile>
	<Link>
	<OptimizeReferences>true</OptimizeReferences>
	<EnableCOMDATFolding>true</EnableCOMDATFolding>
	</Link>
	</ItemDefinitionGroup>
	</Project>

view raw BuildUnitTest.Default.props hosted with ❤ by GitHub

After having number of this kind os project, it is time to weave those together and make a one project file that can build all the projects. Refer below BuildAll.proj. All solution files are listed at the SolutionToBuild. And all unit test that can be run can be liseted at AfterBuild.

	<?xml version="1.0" encoding="utf-8"?>
	<Project
	ToolsVersion="4.0"
	xmlns="http://schemas.microsoft.com/developer/msbuild/2003"
	DefaultTarget="FullBuild">
	<PropertyGroup>
	<SRC_ROOT>..</SRC_ROOT>
	</PropertyGroup>
	<ItemGroup>
	<AllConfigurations Include="Debug"/>
	<!--<AllConfigurations Include="Release"/>-->
	</ItemGroup>
	<ItemGroup>
	<SolutionToBuild Include="$(SRC_ROOT)\Foo\Foo.sln"/>
	<!-- Your solution files goes here -->
	<SolutionToBuild Include="$(SRC_ROOT)\Bar\Bar.sln"/>
	</ItemGroup>
	<PropertyGroup>
	<FullBuildDependsOn>
	$(FullBuildDependsOn);
	BeforeBuild;
	CoreBuild;
	AfterBuild
	</FullBuildDependsOn>
	</PropertyGroup>
	<Target
	Name="FullBuild"
	DependsOnTargets="$(FullBuildDependsOn)">
	</Target>
	<Target Name="BeforeBuild">
	<!-- TODO : Get latest source from version control -->
	</Target>
	<Target Name="CoreBuild">
	<MSBuild
	Projects="@(SolutionToBuild)"
	Properties="Configuration=%(AllConfigurations.Identity)" />
	</Target>
	<Target Name="AfterBuild">
	<!-- TODO : Unit Test -->
	<Exec
	Command="YourUnitTest1.exe"
	WorkingDirectory="$(SRC_ROOT)\YourUnitTestProject\bin\%(AllConfigurations.Identity)"
	/>
	</Target>
	<Target Name="Clean">
	<MSBuild
	Projects="@(SolutionToBuild)"
	Targets="Clean"
	Properties="Configuration=%(AllConfigurations.Identity)" />
	</Target>
	</Project>

view raw BuildAll.proj hosted with ❤ by GitHub

And time to write a simple batch file that can kick off the build process. Refer below BuildAll.bat.

	@echo off
	@SET TARGET=%1
	if "x%1"=="x" SET TARGET=FullBuild
	msbuild BuildAll.proj /t:%TARGET%

view raw BuildAll.bat hosted with ❤ by GitHub

Note that this BuildAll.bat can be used in the command line with vcavr32.bat set. Command window can have below setting.

	Target:
	%windir%\System32\cmd.exe /K cd /d "C:\YourBuildRoot" & %comspec% /k ""C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat"" x86
	Start in:
	C:\YourBuildRoot

view raw command line setting hosted with ❤ by GitHub

This way of making build process doesn't ask for any other tools. Just Visual Studio - demonstrated in here with 2010 - is enough and can be extended to various ways without much effort and learning.

Using Git - setup SSH server

People starts to have more than 1 computer to play with. At my case, I have two PCs and 1 laptop and 1 tablet. I use one PC for work and the other PC for private matter and 1 laptop for work and private in mobile. I like to go to a cafe and work at there with my laptop. I see lots of people come to cafe with their laptop. Nowaday, most of popular cafe has power socket at their table or nearby wall. And of course WIFI.

This convenience isn't that convenient when it comes to move around files between PC and laptop. As a software developer, I need to be able to share source code between these computers. Sometimes those files are for work or private or public source code.

I can put all the files in some server and try to download and modify and upload. Or the server can be a source server. At this case, you need to have a server with a fixed IP for this purpose. This asks for money most of the case.

There are another way. You can use a Git. Git is a distributed version control. With Git, you can write code with any of your computer and share it between computer easily.

Roughly speaking, each computer has it's own source repository. After you write code, you will 'commit' it to the local repository which is keeps the changes in it's own computer. Then you will 'push' the committed change to a global repository which can reside in any of your computer. This global repository is where all the changes resides made by all the computer. This repository doesn't have to be on the web. It can be one of your computer. Then you can use another PC or laptop to 'pull' the changes from the global repository. Then makes changes and 'commit' and then 'push'

The distributed part of Git comes handy when you want to see the changed history. The local repository also has all the changed history what global repository has. When you 'push' the changes, all the committed part comes up to the global repository. And then when you 'pull', the local repository gets history of all the changes made by different computer through global repository.

The global repository should be accessible in every computer you have. One way to achieve this is to run a SSH server. This SSH is a gateway that allows other computer to access the computer. Other computer can read/write files in the global repository through SSH server.

SSH server asks a public key for each user. It can be generated using puttygen like below screen shot. You will send the saved public key to the SSH server administrator but keeps the private key in private. Server administrator knows your name and it's public key. And later, when you try to access the server with your name, the SSH server will ask for matched private key to let you in.

Then as SSH Server administrator, you should register you as an user. In here, refer below screen shot with Bitvise SSH Server. You will add an user in the account and then add pulic key you generated using puttygen.

Now when you use Git, you need to use the matched private key to log in the SSH server. Refer below screen shot using TortoiseGit. You can select your private key to log on specific SSH server. In here, I used my computer as SSH server so 'localhost'

After successful log-in, the tortoise git will execute commands of Git which resides at git installer folder e.g. "C:\Program Files (x86)\Git\libexec\git-core". You need to put this path at the environmental variable PATH. Otherwise, the SSH server will just terminate just after executing any git command. e.g. cmd.exe /c git-upload-pack "F:\depo\my_repo.git" - in this case if git-upload-pack is not in path, the cmd.exe just returns without any error.