Changes between Version 6 and Version 7 of Old/Documentation/OTG/DebugNote

Timestamp:

Feb 17, 2006, 10:34:56 PM (20 years ago)

Author:

zhibinwu

Comment:

—

Old/Documentation/OTG/DebugNote

@@ -164 +164 @@
 So, when it is set to fix rate, each packet will be transmit at this rate 11 times.
               
+
+=== Wrapping Linux Threads in C++ classes ===
+
+Refer to Root software:
+
+esting the root TThread class, we  made some experiences
+running a class member function as a (Linux-)pthread, which might help you.
+
+Since pthread_create (and also the TThread constructor) expects a C function to be run,
+it needs the pointer to the class instance as function argument (4th argument of
+pthread_create), if you want to run a member function of this C++ class.
+When C++ methods are called from within a class, internally the class instance pointer
+("this") is always passed as invisible first argument.
+Thus  the "C" call of any C++ member function by pointer requires
+the class object address as first argument...
+
+For example,
+in root TThread class, the implementation for pthreads (THREAD_PosixThread.cxx)
+starts the member function void* TThread::Fun (which calls your own function
+passed to the TThread constructor) as pthread with the pointer to the TThread instance
+TThread* th as argument:
+{{{
+int ierr = pthread_create(&id, attr, &TThread::Fun,th);
+}}}
+(in method TPosixThread::Run(TThread* th))
+
+Additionally, if you want to run a member void myfunction of any class Myclass as TThread,
+you also have to pass the address to the class as function argument of TThread constructor,
+since TThread::Fun uses a C function call to invoke your function:
+{{{
+ TThread* mythread= new TThread("My Thread",
+         (void(*) (void *)) &Myclass::myfunction,
+         (void*) &Myclass);
+  mythread->Run();
+}}}
+when you create TThread from within class Myclass, you may write
+{{{
+TThread* mythread= new TThread("My Thread",
+         (void(*) (void *)) &myfunction,
+         (void*) this);
+  mythread->Run();
+}}}
+The required cast of &myfunction produced a compiler warning in our tests
+(egcs-2.91.66 Debian GNU/Linux (egcs-1.1.2 release)); however, the example
+was compiled and runs.
+
+And
+please don't mix a ptr-to-function and a ptr-to-member-function.
+The former is just the address of a function. The later is
+a structure containing
+
+   * the function address for non-virtual functions
+   * the vtable index for virtual functions
+   * the this pointer offset
+
+The representation of the structure is implementation specific,
+and does for some compilers even depend on whether the class
+has virtual functions or multiple inheritance or not.
+
+All this is needed to calculate 
+    *   the actual entry point address
+    *   and the effective this pointer
+when the ptr-to-member-function is finally used in a call.
+In cases like multiple inherited base classes with virtual
+functions in virtual base classes things get nontrivial here!
+
+Inspect the C++ lanuage definition for the allowed conversions
+and casts of a ptr-to-member-function, and you'll see, there are
+very few.
+
+In the light of all this I wonder portable Joern's code example is.
+
+Beyond that, the code
+{{{
+ TThread* mythread= new TThread("My Thread",
+         (void(*) (void *)) &Myclass::myfunction,
+         (void*) &Myclass);
+}}}
+will probably not give the desired result if Myclass uses
+multiple inheritance and myfunction is from one of the base
+classes (that's why the PTMF struct may contain a this offset).
+
+And
+
+Pthread standard allows only simple C function.
+
+TThread::Fun is static member of a class. A static member function == C function.
+So it will work with all compilers/platforms.
+I introduced static member function TThread::Fun and not simple C function
+only do not pollute the name space. 
+
+But you still can use nonstatic virtual member  function in Pthread.
+
+For example you want to call virtual finction void A::F()
+By C++ rules you mas provide 2 pointers:
+ A* p  - pointer to class instance
+ void (A::*f)()  - pointer to function
+
+ Then you calculate pointer f = &A::F;
+
+User function for Pthread
+{{{
+user(void* adr)
+{
+  A inst;
+  (A::*f)() = ((A::*)())adr;
+  (inst.*f)();
+}
+}}}
+In the example instance of A:: created inside of function.
+But it is easy to pass this pointer via intermediate object
+which keeps both poiners, to instance and to function.
+Pointer to this object passed by adr uf user routine.
+
+So, there is no any limitation in THread::
+
+
+
+