Passing class function to pthread_create
(1)
template<class TH, void(TH::*bar)(void *)>
void* thx(void* p) {
    (static_cast<TH*>(p)->*bar)(p);
    return 0;
}
Class X {
    void foo(void *val);
}
void X::foo(void *k){
}
pthread_create(&thread_id,&threadattr,thx<X,&X::foo>,(void *)&var);
(2)
struct threadParams{
    void * instance;
    int val;
};
void* start_thread(void* arg) {
    struct threadParams *thx=(struct threadParams *)arg;
    static_cast<Streamer*>(thx->instance)->bar(thx->val);
}
Class Streamer{
    void foo();
    void bar(int x);
}
void Streamer::foo(){
    struct threadParams thx;
    thx.instance =this;
    thx.val=10;   
    pthread_create(&thpool,&threadattr,start_thread,&thx);
}

---

Bubble sort exercise in CUDA

Not a perfect and professional implementation. Hopefully serves as an example for programming using the NVIDIA GPU.
Recursion and dynamic memory allocation on the GPU from within the "device" code not supported by the GPU.
Hence using an in-memory sort without recursion. Source code is found at the end of the page as attachments.

• Create 2 blocks with 2 threads each
• The array of numbers is partitioned into 4 sets. first 2 sets are sorted in parallel on the first block (2 threads), second 2 sets are sorted in parallel on the second block (2 threads).
• first 2 sorted lists and second 2 sorted lists are reordered as a binary heap in parallel (2 threads)
  
• the two binary heaps are once again reordered as a binary heap by merging (1 thread)
  
• the output is a binary heap and not the fully sorted list of numbers