Passing template argument to template function in a thread - c++

Question

I'm new to templates, so I decided to write out unit tests for some concurrent code I am writing, but I can't seem to get them to compile. The specific error is:
error C2664: 'std::thread::thread(const std::thread &)' : cannot convert argument 1 from 'void (__cdecl *)(lock &)' to 'void (__cdecl &)(Utility_UnitTests::emptyLock &)'
1> None of the functions with this name in scope match the target type
1> w:\code dumpster\utility_unittests\utspinlock.cpp(88) : see reference to function template instantiation 'void Utility_UnitTests::UTSpinLock::lockContension<Utility_UnitTests::emptyLock>(lock &)' being compiled
1> with
1> [
1> lock=Utility_UnitTests::emptyLock
1> ]
The issue is pretty clear from the compiler, I am not passing the correct type, but I have no clue how to fix it! Thanks in advance!
EDIT: I forgot to mention, I am using Visual Studio 2013
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace Utility_UnitTests
{
typedef utils::threading::SpinLock<utils::threading::backoff::empty> emptyLock;
typedef utils::threading::SpinLock<utils::threading::backoff::yield> yieldingLock;
typedef utils::threading::SpinLock<utils::threading::backoff::pause> pausingLock;
TEST_CLASS(UTSpinLock)
{
public:
template<typename lock>
void lockAndSleepT(lock &l)
{
l.lock();
std::this_thread::sleep_for(std::chrono::nanoseconds(10));
l.unlock();
}
template<typename lock>
void lockContension(lock &l)
{
std::thread t1(&UTSpinLock::lockAndSleepT<lock>, this, std::ref(l));
Assert::AreEqual(true, l.isLocked());
t1.join();
Assert::AreEqual(false, l.isLocked());
}
TEST_METHOD(testLockContension)
{
UTSpinLock::lockContension(m_emptySpin);
UTSpinLock::lockContension(m_yieldingSpin);
UTSpinLock::lockContension(m_pausingSpin);
}
private:
emptyLock m_emptySpin;
yieldingLock m_yieldingSpin;
pausingLock m_pausingSpin;
};
}

Answer 1

First of all, this is certainly a bug in the MSVC implementation. It seems to be having trouble when the first argument to std::thread is a pointer to a member function template. On my machine, the 64-bit compiler produces the same error message, while the 32-bit compiler crashes. Thankfully, you can work around this in quite a few ways, all involving not directly pass a pointer to a member function template to thread.
Option 1 - as you've discovered, creating a bind expression and passing that to thread works.
Option 2 - rewrite the class so that it is a template, and the member functions are not.
template<typename lock>
struct UTSpinLock
{
public:
void lockAndSleepT(lock &l)
{}
void lockContension(lock &l)
{
std::thread t1(&UTSpinLock::lockAndSleepT, this, std::ref(l));
t1.join();
}
};
Option 3 - leave the class definition unchanged, and wrap the pointer to member function template in std::mem_fn
std::thread t1(std::mem_fn(&UTSpinLock::lockAndSleepT<lock>), this, std::ref(l));
Option 4 - no change to the class definition again, this time pass a lambda expression to thread
std::thread t1([&, this](){ lockAndSleepT(l); });

Answer 2

Special thank to WhozCraig! I would accept his answer, but, for some reason, I can't. For those that are interested, I changed:
template<typename lock>
void lockContension(lock &l)
{
std::thread t1(&UTSpinLock::lockAndSleepT<lock>, this, std::ref(l));
Assert::AreEqual(true, l.isLocked());
t1.join();
Assert::AreEqual(false, l.isLocked());
}
To:
template<typename lock>
void lockContension(lock &l)
{
auto bounded = std::bind(&UTSpinLock::lockAndSleepT<lock>, this, std::placeholders::_1);
std::thread t1(bounded, std::ref(l));
Assert::AreEqual(true, l.isLocked());
t1.join();
Assert::AreEqual(false, l.isLocked());
}