boost::this_thread

[aj3423]

void fn() {
    try {
        while(1) {
            this_thread::interruption_point();//
            Sleep(1);
        }
    } catch(...) {}
}

thread thrd(fn);
thrd.join();


// to interrupt the thrd, call this in some other thread
//thrd.interrupt(); 

how does this_thread::interruption_point() work?
i looked into the source, it calls the get_current_thread_data() to get some data that belongs to the thread:

DWORD current_thread_tls_key=TLS_OUT_OF_INDEXES;

//....

        detail::thread_data_base* get_current_thread_data()
        {
            if(current_thread_tls_key==TLS_OUT_OF_INDEXES)
            {
                return 0;
            }
            return (detail::thread_data_base*)TlsGetValue(current_thread_tls_key);
        }
        

now i know on win32, boost uses TLS to store the thread data, but still don't understand how the function get_current_thread_data works. It depends on current_thread_tls_key, but it seems to be a global value,
every time a thread starts, the current_thread_tls_key changes.

here's the source file:

thread.hpp: http://pastebin.com/hp5fcq5E
thread.cpp: http://pastebin.com/WqVdDcNM


Thanks.

[kbw]

Thread classes use a data structure (the class instance) to hold per-thread information. Strickly speaking, the use of TLS is a nicety. If thread data isn't stored in the OS's thread local storage facility, it can be held in the class, it's no big deal.

Boost is using the class to hold the TLS index. So it's using a mixture of both techniques. It's holding current_thread_tls_key in the class instance, and that just points into the OS's TLS mechanism.

As you can see, it's not necessary, and will fail if you run out of TLS slots.

[coder777]

how does this_thread::interruption_point() work?

It throws [unfortunately] an exception

[aj3423]

but how this_thread::interruption_point() works, it's a global function, how could a global function knows which thread it belongs to?
for example:

void fn() {
	this_thread::interruption_point();
}

thread t_1(fn);
thread t_2(fn);

in this case, when the interruption_point() executes, how does it know whether it's in t_1 or t_2 ?

[coder777]

but how this_thread::interruption_point() works, it's a global function, how could a global function knows which thread it belongs to?

You can always get the id of the currently running thread. Data stored according to this id can be used to accomplish this.

It could be a simple bool in the TLS (explained by kbw) set by interrupt() and reset by interruption_point()

[aj3423]

oh.. win32::GetCurrentThreadId
Thanks.

[aj3423]

here's my simple implementation:)

#pragma once

#include <windows.h>
#include <functional>
using namespace std;

#include "singleton.h"

namespace thread {


struct thread;
DWORD WINAPI ThreadFunc(void* thrd);
thread* get_current_thread_data();
void interruption_point();

// #define TLS_OUT_OF_INDEXES 0xFFFFFFFF
DWORD current_thread_tls_key = TLS_OUT_OF_INDEXES;

struct tls_alloc_once : public singleton<tls_alloc_once> {
	tls_alloc_once() {
		current_thread_tls_key = TlsAlloc();
	}
};

struct interrupt_exception {};

struct thread_data {
	bool interrupted;
	typedef function<void()> f_type;
	f_type _f;

	thread_data() : interrupted(false) {}

	template<typename F>
	thread_data(F f) : _f(f), interrupted(false) {}

	void run() {
		if(_f) _f();
	}
};


struct thread {
	thread_data _data;
	HANDLE _h;
	DWORD _id;

	thread() {}
	thread(thread_data data) : _data(data) {}

	void start() {
		_h = CreateThread(NULL, 0, ThreadFunc, (void*)this, 0, &_id);
	}
	void join() {
		::WaitForSingleObject(_h, INFINITE);
	}
	void operator=(thread_data data) {
		_data = data;
	}
	void interrupt() {
		_data.interrupted = true;
	}
};
DWORD WINAPI ThreadFunc(void* thrd) {
	tls_alloc_once::instance();
	if(current_thread_tls_key == TLS_OUT_OF_INDEXES)
		throw std::exception("tls alloc error");

	if(!::TlsSetValue(current_thread_tls_key, thrd)) 
		throw std::exception("tls setvalue error");
	
	try {
		static_cast<thread*>(thrd)->_data.run();
	} catch(interrupt_exception&) {}
	return 0;
}
void interruption_point() {
	thread* thrd = get_current_thread_data();
	if(!thrd) throw std::exception("no thread, wth");
	if(thrd->_data.interrupted) {
		thrd->_data.interrupted = false;
		throw interrupt_exception();
	}
}
thread* get_current_thread_data() {
	if(current_thread_tls_key == TLS_OUT_OF_INDEXES) {
		return NULL;
	}
	return (thread*)TlsGetValue(current_thread_tls_key);
}

}; // end of namespace thread