Category: C/C++

One of the two basic synchronisation primitives in multithreaded programming is called “condition variables”. Here’s a small example:

bool something_happened;
boost::mutex m;
boost::condition_variable c;
void thread1() {
    boost::mutex::scoped_lock(m);
    while (!something_happened) {
        c.wait(m);
    }
}
void thread2() {
    // do lots of work
    boost::mutex::scoped_lock(m);
    something_happened = true;
    c.notify_one();
}

bool something_happened;

boost::mutex m;

boost::condition_variable c;

void thread1() {

boost::mutex::scoped_lock(m);

while (!something_happened) {

c.wait(m);

}

void thread2() {

// do lots of work

boost::mutex::scoped_lock(m);

something_happened = true;

c.notify_one();

}

Here, the call to “c.wait()” unlocks the mutex (allowing the other thread to eventually lock it), and suspends the calling thread. When another thread calls ‘notify’, the first thread wakes up, locks the mutex again (implicitly, inside ‘wait’), sees that variable is set to ‘true’ and goes on.

But why do we need the while loop, can’t we write:

    if (!something_happened) {
        c.wait(m);
    }

if (!something_happened) {

c.wait(m);

}

We can’t. And the killer reason is that ‘wait’ can return without any ‘notify’ call. That’s called spurious wakeup and is explicitly allowed by POSIX. Essentially, return from ‘wait’ only indicates that the shared data might have changed, so that data must be evaluated again.

Okay, so why this is not fixed yet? The first reason is that nobody wants to fix it. Wrapping call to ‘wait’ in a loop is very desired for several other reasons. But those reasons require explanation, while spurious wakeup is a hammer that can be applied to any first year student without fail.

The second reason is that fixing this is supposed to be hard. Most sources I’ve seen say that fixing that would require very large overhead on certain architectures. Strangely, no details were ever given, which made me wonder if avoiding spurious wakeups is simple, but all the threading experts secretly decided to tell everybody it’s hard.

After asking on comp.programming.thread, I at least know the reason for Linux (thanks to Ben Hutchings). Internally, wait is implemented as a call to the ‘futex’ system call. Each blocking system call on Linux returns abruptly when the process receives a signal — because calling signal handler from kernel call is tricky. What if the signal handler calls some other system function? And a new signal arrives? It’s easy to run out of kernel stack for a process. Exactly because each system call can be interrupted, when glibc calls any blocking function, like ‘read’, it does it in a loop, and if ‘read’ returns EINTR, calls ‘read’ again.

Can the same trick be used to conditions? No, because the moment we return from ‘futex’ call, another thread can send us notification. And since we’re not waiting inside ‘futex’, we’ll miss the notification(A third thread can get it, and change the value of predicate. — gonwan). So, we need to return to the caller, and have it reevaluate the predicate. If another thread indeed set it to true, we’ll break out of the loop.

So much for spurious wakeups on Linux. But I’m still very interested to know what the original reasons were.

==============================
Also see the explanation for spurious wakeups on the linux man page: pthread_cond_signal.
Last note: PulseEvent() in windows(manual-reset) = pthread_cond_signal() in linux, while SetEvent() in windows(auto-reset) = pthread_cond_broadcast() in linux, see here and here. And spurious wakeups are also possible on windows when using condition variables.

C++ Template Function Overload & Specialization

July 6, 2014 by gonwan·0 Comments

Currently reading C++ Templates: The Complete Guide these days. Just summarize confusions about template function overload & specialization.

#include <iostream>
using namespace std;

template <typename T>
void foo(T) {
    cout << "in foo(T)" << endl;    
}

/* overload only */
template <typename T>
void foo(T *) {
    cout << "in foo(T *)" << endl;
}

/* full specialization of foo(T *) */
template <>
void foo<int>(int *) {
    cout << "in foo(int *)" << endl;
}

int main()
{
    /* The compiler does overload resolution before it looks at specializations. */
    foo(new int);
    return 0;
}

#include <iostream>

using namespace std;

template <typename T>

void foo(T) {

cout << "in foo(T)" << endl;

}

/* overload only */

template <typename T>

void foo(T *) {

cout << "in foo(T *)" << endl;

}

/* full specialization of foo(T *) */

template <>

void foo<int>(int *) {

cout << "in foo(int *)" << endl;

}

int main()

{

/* The compiler does overload resolution before it looks at specializations. */

foo(new int);

return 0;

}

It first selects foo(T *) over foo(T), and use the specialized version foo<int>(int *).

#include <iostream>
using namespace std;

template <typename T>
void foo(T) {
    cout << "in foo(T)" << endl;    
}

/* overload only */
template <typename T>
void foo(T *) {
    cout << "in foo(T *)" << endl;
}

/* full specialization of foo(T) */
template <>
void foo<int *>(int *) {
    cout << "in foo(int *)" << endl;
}

#if 0
/* function partial specialization, not allowed in c++ specification. */
template <typename T>
void foo<T *>(T *) {
    cout << "in foo<T *>(T *)" << endl;
}
#endif

int main()
{
    /* The compiler does overload resolution before it looks at specializations. */
    foo(new int);
    return 0;
}

#include <iostream>

using namespace std;

template <typename T>

void foo(T) {

cout << "in foo(T)" << endl;

}

/* overload only */

template <typename T>

void foo(T *) {

cout << "in foo(T *)" << endl;

}

/* full specialization of foo(T) */

template <>

void foo<int *>(int *) {

cout << "in foo(int *)" << endl;

}

#if 0

/* function partial specialization, not allowed in c++ specification. */

template <typename T>

void foo<T *>(T *) {

cout << "in foo<T *>(T *)" << endl;

}

#endif

int main()

{

/* The compiler does overload resolution before it looks at specializations. */

foo(new int);

return 0;

}

Here it just selects foo(T *). The foo<int *>(int *) version is not a specialization of it, and is not selected.

Note the syntax of function partial specialization(if possible) here.

Difference between overload and specilization from the book:

In Chapter 12 we discussed how class templates can be partially specialized, whereas function templates are simply overloaded. The two mechanisms are somewhat different.

Partial specialization doesn’t introduce a completely new template: It is an extension of an existing template (the primary template). When a class template is looked up, only primary templates are considered at first. If, after the selection of a primary template, it turns out that there is a partial specialization of that template with a template argument pattern that matches that of the instantiation, its definition (in other words, its body) is instantiated instead of the definition of the primary template. (Full template specializations work exactly the same way.)

In contrast, overloaded function templates are separate templates that are completely independent of one another. When selecting which template to instantiate, all the overloaded templates are considered together, and overload resolution attempts to choose one as the best fit. At first this might seem like an adequate alternative, but in practice there are a number of limitations:

– It is possible to specialize member templates of a class without changing the definition of that class. However, adding an overloaded member does require a change in the definition of a class. In many cases this is not an option because we may not own the rights to do so. Furthermore, the C++ standard does not currently allow us to add new templates to the std namespace, but it does allow us to specialize templates from that namespace.

– To overload function templates, their function parameters must differ in some material way. Consider a function template R convert(T const&) where R and T are template parameters. We may very well want to specialize this template for R = void, but this cannot be done using overloading.

– Code that is valid for a nonoverloaded function may no longer be valid when the function is overloaded. Specifically, given two function templates f(T) and g(T) (where T is a template parameter), the expression g(&f) is valid only if f is not overloaded (otherwise, there is no way to decide which f is meant).

– Friend declarations refer to a specific function template or an instantiation of a specific function template. An overloaded version of a function template would not automatically have the privileges granted to the original template.

Setting up Pretty Printers in GDB

July 2, 2014 by gonwan·0 Comments

There’s an official page on gcc website: https://sourceware.org/gdb/wiki/STLSupport. And here is how to set up it under Ubuntu.

Under Ubuntu 12.04(Precise), simply install the libstdc++6 debug package. It includes the python script for pretty printers:

# sudo apt-get install libstdc++6-4.6-dbg

1	# sudo apt-get install libstdc++6-4.6-dbg

Create a .gdbinit file in your home directory, with the content:

python
import sys
sys.path.insert(0, '/usr/share/gcc-4.6/python')
from libstdcxx.v6.printers import register_libstdcxx_printers
register_libstdcxx_printers (None)
end

python

import sys

sys.path.insert(0, '/usr/share/gcc-4.6/python')

from libstdcxx.v6.printers import register_libstdcxx_printers

register_libstdcxx_printers (None)

end

My test program looks like:

#include <string>
#include <vector>
using namespace std;

int main()
{
    string s = "test";
    vector<int> vi;
    vi.push_back(1);
    vi.push_back(2);
    vi.push_back(3);
    return 0;
}

#include <string>

#include <vector>

using namespace std;

int main()

{

string s = "test";

vector<int> vi;

vi.push_back(1);

vi.push_back(2);

vi.push_back(3);

return 0;

}

Build it with debugging enabled(-g):

# g++ -g test.cpp -o test

1	# g++ -g test.cpp -o test

Debug it with GDB:

# gdb -q test 
Reading symbols from /home/gonwan/test...done.
(gdb) b 12
Breakpoint 1 at 0x8048842: file test.cpp, line 12.
(gdb) r
Starting program: /home/gonwan/test 

Breakpoint 1, main () at test.cpp:12
12	    return 0;
(gdb) p s
$1 = "test"
(gdb) p vi
$2 = std::vector of length 3, capacity 4 = {1, 2, 3}
(gdb)

# gdb -q test

Reading symbols from /home/gonwan/test...done.

(gdb) b 12

Breakpoint 1 at 0x8048842: file test.cpp, line 12.

(gdb) r

Starting program: /home/gonwan/test

Breakpoint 1, main () at test.cpp:12

12 return 0;

(gdb) p s

$1 = "test"

(gdb) p vi

$2 = std::vector of length 3, capacity 4 = {1, 2, 3}

(gdb)

Without pretty printers, the output is tedious and hard to understand:

$ gdb -q test 
Reading symbols from /home/gonwan/test...done.
(gdb) set print pretty
(gdb) b 12
Breakpoint 1 at 0x8048842: file test.cpp, line 12.
(gdb) r
Starting program: /home/gonwan/test 

Breakpoint 1, main () at test.cpp:12
12	    return 0;
(gdb) p s
$1 = {
  static npos = <optimized out>, 
  _M_dataplus = {
    <std::allocator<char>> = {
      <__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>}, 
    members of std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider: 
    _M_p = 0x804c014 "test"
  }
}
(gdb) p vi
$2 = {
  <std::_Vector_base<int, std::allocator<int> >> = {
    _M_impl = {
      <std::allocator<int>> = {
        <__gnu_cxx::new_allocator<int>> = {<No data fields>}, <No data fields>}, 
      members of std::_Vector_base<int, std::allocator<int> >::_Vector_impl: 
      _M_start = 0x804c040, 
      _M_finish = 0x804c04c, 
      _M_end_of_storage = 0x804c050
    }
  }, <No data fields>}
(gdb)

$ gdb -q test

Reading symbols from /home/gonwan/test...done.

(gdb) set print pretty

(gdb) b 12

Breakpoint 1 at 0x8048842: file test.cpp, line 12.

(gdb) r

Starting program: /home/gonwan/test

Breakpoint 1, main () at test.cpp:12

12 return 0;

(gdb) p s

$1 = {

static npos = <optimized out>,

_M_dataplus = {

<std::allocator<char>> = {

<__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>},

members of std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Alloc_hider:

_M_p = 0x804c014 "test"

}

(gdb) p vi

$2 = {

<std::_Vector_base<int, std::allocator<int> >> = {

_M_impl = {

<std::allocator<int>> = {

<__gnu_cxx::new_allocator<int>> = {<No data fields>}, <No data fields>},

members of std::_Vector_base<int, std::allocator<int> >::_Vector_impl:

_M_start = 0x804c040,

_M_finish = 0x804c04c,

_M_end_of_storage = 0x804c050

}

}, <No data fields>}

(gdb)

Under Ubuntu 14.04(Trusty), the 4.8 version of debug package should be installed:

# sudo apt-get install libstdc++6-4.8-dbg

1	# sudo apt-get install libstdc++6-4.8-dbg

There’s an additional step. Since GDB in Trusty is built with python3, not python2, and the python scripts for pretty printers are in python2 syntax. A simple conversion is required:

# sudo 2to3 -w /usr/share/gcc-4.8/python/libstdcxx/v6/printers.py

1	# sudo 2to3 -w /usr/share/gcc-4.8/python/libstdcxx/v6/printers.py

Backup it before conversion if neccessary.

Sharing Mutex and Condition Variable Between Processes

April 10, 2014 by gonwan·2 Comments

As title, the key is to set an attribute(PTHREAD_PROCESS_SHARED) to the mutex/condition variable using pthread_mutexattr_setpshared() or pthread_condattr_setpshared(). Without these function calls, the parent in the following code will not get signaled forever.

/*
 * gcc mutex.c -o mutex -lrt
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MYMUTEX "/mymutex"
#define MYCOND  "/mycond"

int main(int argc, char* argv[])
{
    pthread_cond_t *cond;
    pthread_mutex_t *mutex;
    int cond_id, mutex_id;
    int mode = S_IRWXU | S_IRWXG;
    /* mutex */
    mutex_id = shm_open(MYMUTEX, O_CREAT | O_RDWR | O_TRUNC, mode);
    if (mutex_id < 0) {
        perror("shm_open failed with " MYMUTEX);
        return -1;
    }
    if (ftruncate(mutex_id, sizeof(pthread_mutex_t)) == -1) {
        perror("ftruncate failed with " MYMUTEX);
        return -1;
    }
    mutex = (pthread_mutex_t *) mmap(NULL, sizeof(pthread_mutex_t), PROT_READ | PROT_WRITE, MAP_SHARED, mutex_id, 0);
    if (mutex == MAP_FAILED) {
        perror("mmap failed with " MYMUTEX);
        return -1;
    }
    /* cond */
    cond_id = shm_open(MYCOND, O_CREAT | O_RDWR | O_TRUNC, mode);
    if (cond_id < 0) {
        perror("shm_open failed with " MYCOND);
        return -1;
    }
    if (ftruncate(cond_id, sizeof(pthread_cond_t)) == -1) {
        perror("ftruncate failed with " MYCOND);
        return -1;
    }
    cond = (pthread_cond_t *) mmap(NULL, sizeof(pthread_cond_t), PROT_READ | PROT_WRITE, MAP_SHARED, cond_id, 0);
    if (cond == MAP_FAILED) {
        perror("ftruncate failed with " MYCOND);
        return -1;
    }
    /* set mutex shared between processes */
    pthread_mutexattr_t mattr;
    pthread_mutexattr_init(&mattr);
    pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
    pthread_mutex_init(mutex, &mattr);
    pthread_mutexattr_destroy(&mattr);
    /* set condition shared between processes */
    pthread_condattr_t cattr;
    pthread_condattr_init(&cattr);
    pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
    pthread_cond_init(cond, &cattr);
    pthread_condattr_destroy(&cattr);
    /*************************************/
    pid_t pid;
    if ((pid = fork()) < 0) {
        perror("fork failure");
        return -1;
    } else if (pid == 0) { /* child */
        sleep(5);
        pthread_mutex_lock(mutex);
        pthread_cond_signal(cond);
        printf("child signaled\n");
        pthread_mutex_unlock(mutex);
        exit(0);
    } else { /* parent */
        printf("parent waiting on condition\n");
        pthread_mutex_lock(mutex);
        pthread_cond_wait(cond, mutex);
        printf("parent signaled by child, wake up!!!\n");
        pthread_mutex_unlock(mutex);
        pthread_mutex_destroy(mutex);
        pthread_cond_destroy(cond);
        shm_unlink(MYCOND);
        shm_unlink(MYMUTEX);
    }
    return 0;
}

* gcc mutex.c -o mutex -lrt

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <pthread.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <fcntl.h>

#define MYMUTEX "/mymutex"

#define MYCOND "/mycond"

int main(int argc, char* argv[])

{

pthread_cond_t *cond;

pthread_mutex_t *mutex;

int cond_id, mutex_id;

int mode = S_IRWXU | S_IRWXG;

/* mutex */

mutex_id = shm_open(MYMUTEX, O_CREAT | O_RDWR | O_TRUNC, mode);

if (mutex_id < 0) {

perror("shm_open failed with " MYMUTEX);

return -1;

}

if (ftruncate(mutex_id, sizeof(pthread_mutex_t)) == -1) {

perror("ftruncate failed with " MYMUTEX);

return -1;

}

mutex = (pthread_mutex_t *) mmap(NULL, sizeof(pthread_mutex_t), PROT_READ | PROT_WRITE, MAP_SHARED, mutex_id, 0);

if (mutex == MAP_FAILED) {

perror("mmap failed with " MYMUTEX);

return -1;

}

/* cond */

cond_id = shm_open(MYCOND, O_CREAT | O_RDWR | O_TRUNC, mode);

if (cond_id < 0) {

perror("shm_open failed with " MYCOND);

return -1;

}

if (ftruncate(cond_id, sizeof(pthread_cond_t)) == -1) {

perror("ftruncate failed with " MYCOND);

return -1;

}

cond = (pthread_cond_t *) mmap(NULL, sizeof(pthread_cond_t), PROT_READ | PROT_WRITE, MAP_SHARED, cond_id, 0);

if (cond == MAP_FAILED) {

perror("ftruncate failed with " MYCOND);

return -1;

}

/* set mutex shared between processes */

pthread_mutexattr_t mattr;

pthread_mutexattr_init(&mattr);

pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);

pthread_mutex_init(mutex, &mattr);

pthread_mutexattr_destroy(&mattr);

/* set condition shared between processes */

pthread_condattr_t cattr;

pthread_condattr_init(&cattr);

pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);

pthread_cond_init(cond, &cattr);

pthread_condattr_destroy(&cattr);

/*************************************/

pid_t pid;

if ((pid = fork()) < 0) {

perror("fork failure");

return -1;

} else if (pid == 0) { /* child */

sleep(5);

pthread_mutex_lock(mutex);

pthread_cond_signal(cond);

printf("child signaled\n");

pthread_mutex_unlock(mutex);

exit(0);

} else { /* parent */

printf("parent waiting on condition\n");

pthread_mutex_lock(mutex);

pthread_cond_wait(cond, mutex);

printf("parent signaled by child, wake up!!!\n");

pthread_mutex_unlock(mutex);

pthread_mutex_destroy(mutex);

pthread_cond_destroy(cond);

shm_unlink(MYCOND);

shm_unlink(MYMUTEX);

}

return 0;

}

Shared memory is used to share the mutex and condition variable.

NOTE: The process-shared mutex attribute isn’t universally supported yet. You should confirm before using them.

Updated Oct 14, 2020: Fixed pthread_mutexattr_t and pthread_condattr_t initialization.

Pre/Post-main Function Call Implementation in C

February 13, 2014 by gonwan·0 Comments

In C++, pre/post-main function call can be implemented using a global class instance. Its constructor and destructor are invoked automatically before and after the main function. But in C, no such mechanism. Actually, there’s a glib implementation that can help. You may want to read my previous post about CRT sections of MSVC. I just copy the code and do some renaming:

#include <stdlib.h>
#if defined (_MSC_VER)
#if (_MSC_VER >= 1500)
/* Visual Studio 2008 and later have __pragma */
#define HAS_CONSTRUCTORS
#define DEFINE_CONSTRUCTOR(_func) \
    static void _func(void); \
    static int _func ## _wrapper(void) { _func(); return 0; } \
    __pragma(section(".CRT$XCU",read)) \
    __declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _wrapper;
#define DEFINE_DESTRUCTOR(_func) \
    static void _func(void); \
    static int _func ## _constructor(void) { atexit (_func); return 0; } \
    __pragma(section(".CRT$XCU",read)) \
    __declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _constructor;
#elif (_MSC_VER >= 1400)
/* Visual Studio 2005 */
#define HAS_CONSTRUCTORS
#pragma section(".CRT$XCU",read)
#define DEFINE_CONSTRUCTOR(_func) \
    static void _func(void); \
    static int _func ## _wrapper(void) { _func(); return 0; } \
    __declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _wrapper;
#define DEFINE_DESTRUCTOR(_func) \
    static void _func(void); \
    static int _func ## _constructor(void) { atexit (_func); return 0; } \
    __declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _constructor;
#else
/* Visual Studio 2003 and early versions should use #pragma code_seg() to define pre/post-main functions. */
#error Pre/Post-main function not supported on your version of Visual Studio.
#endif
#elif (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
#define HAS_CONSTRUCTORS
#define DEFINE_CONSTRUCTOR(_func) static void __attribute__((constructor)) _func (void);
#define DEFINE_DESTRUCTOR(_func) static void __attribute__((destructor)) _func (void);
#else
/* not supported */
#endif

#include <stdlib.h>

#if defined (_MSC_VER)

#if (_MSC_VER >= 1500)

/* Visual Studio 2008 and later have __pragma */

#define HAS_CONSTRUCTORS

#define DEFINE_CONSTRUCTOR(_func) \

static void _func(void); \

static int _func ## _wrapper(void) { _func(); return 0; } \

__pragma(section(".CRT$XCU",read)) \

__declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _wrapper;

#define DEFINE_DESTRUCTOR(_func) \

static void _func(void); \

static int _func ## _constructor(void) { atexit (_func); return 0; } \

__pragma(section(".CRT$XCU",read)) \

__declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _constructor;

#elif (_MSC_VER >= 1400)

/* Visual Studio 2005 */

#define HAS_CONSTRUCTORS

#pragma section(".CRT$XCU",read)

#define DEFINE_CONSTRUCTOR(_func) \

static void _func(void); \

static int _func ## _wrapper(void) { _func(); return 0; } \

__declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _wrapper;

#define DEFINE_DESTRUCTOR(_func) \

static void _func(void); \

static int _func ## _constructor(void) { atexit (_func); return 0; } \

__declspec(allocate(".CRT$XCU")) static int (* _array ## _func)(void) = _func ## _constructor;

#else

/* Visual Studio 2003 and early versions should use #pragma code_seg() to define pre/post-main functions. */

#error Pre/Post-main function not supported on your version of Visual Studio.

#endif

#elif (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)

#define HAS_CONSTRUCTORS

#define DEFINE_CONSTRUCTOR(_func) static void __attribute__((constructor)) _func (void);

#define DEFINE_DESTRUCTOR(_func) static void __attribute__((destructor)) _func (void);

#else

/* not supported */

#endif

One limitation in glib code is the lack of support for VS2003 and early versions. #pragma code_seg() is used to implement the same function:

/*
 * cl ctor.c
 * gcc ctor.c -o ctor
 */
#include "ctor.h"
#include <stdio.h>

#ifdef HAS_CONSTRUCTORS
DEFINE_CONSTRUCTOR(before)
DEFINE_DESTRUCTOR(after)
#else
#ifdef _MSC_VER
static void before(void);
static void after(void);
#pragma data_seg(".CRT$XCU")
static void (*msc_ctor)(void) = before;
#pragma data_seg(".CRT$XPU")
static void (*msc_dtor)(void) = after;
#pragma data_seg()
#endif
#endif

void before()
{
    printf("before main\n");
}

void after()
{
    printf("after main\n");
}

int main()
{
    printf("in main\n");
    return 0;
}

* cl ctor.c

* gcc ctor.c -o ctor

#include "ctor.h"

#include <stdio.h>

#ifdef HAS_CONSTRUCTORS

DEFINE_CONSTRUCTOR(before)

DEFINE_DESTRUCTOR(after)

#else

#ifdef _MSC_VER

static void before(void);

static void after(void);

#pragma data_seg(".CRT$XCU")

static void (*msc_ctor)(void) = before;

#pragma data_seg(".CRT$XPU")

static void (*msc_dtor)(void) = after;

#pragma data_seg()

#endif

void before()

{

printf("before main\n");

}

void after()

{

printf("after main\n");

}

int main()

{

printf("in main\n");

return 0;

}

Output from msvc/gcc:

before main
in main
after main

before main

in main

after main

0x2B|~0x2B

My broken wings still strong enough to cross the ocean with.

Category: C/C++

Spurious Wakeups

C++ Template Function Overload & Specialization

Setting up Pretty Printers in GDB

Sharing Mutex and Condition Variable Between Processes

Pre/Post-main Function Call Implementation in C