enable_depend

enable_cassert

enable_thread_safety

enable_thread_safety_force

with_tcl

with_tclconfig

with_perl

--enable-dtrace build with DTrace support

--enable-depend turn on automatic dependency tracking

--enable-cassert enable assertion checks (for debugging)

--disable-thread-safety make client libraries thread-safe

--enable-thread-safety-force

force thread-safety despite thread test failure

--disable-thread-safety disable thread-safety in client libraries

--disable-float4-byval disable float4 passed by value

--disable-float8-byval disable float8 passed by value

--disable-largefile omit support for large files

fi

# Check whether --enable-thread-safety-force was given.

if test "${enable_thread_safety_force+set}" = set; then

enableval=$enable_thread_safety_force;

case $enableval in

yes)

:

;;

no)

:

;;

*)

{ { $as_echo "$as_me:$LINENO: error: no argument expected for --enable-thread-safety-force option" >&5

$as_echo "$as_me: error: no argument expected for --enable-thread-safety-force option" >&2;}

{ (exit 1); exit 1; }; }

;;

esac

else

enable_thread_safety_force=no

fi

if test "$enable_thread_safety" = yes -o \

"$enable_thread_safety_force" = yes; then

enable_thread_safety="yes"# for 'force'

cat >>confdefs.h <<\_ACEOF

#define ENABLE_THREAD_SAFETY 1

_ACEOF

fi

{ $as_echo "$as_me:$LINENO: result: $enable_thread_safety" >&5

$as_echo "$enable_thread_safety" >&6; }

if test "$PTHREAD_CC" != "$CC"; then

{ { $as_echo "$as_me:$LINENO: error:

PostgreSQL does not support platforms that require a special compiler

for thread safety." >&5

for thread safety; use --disable-thread-safety to disable thread safety." >&5

$as_echo "$as_me: error:

PostgreSQL does not support platforms that require a special compiler

for thread safety." >&2;}

for thread safety; use --disable-thread-safety to disable thread safety." >&2;}

{ (exit 1); exit 1; }; }

fi

if test "x$ac_cv_header_pthread_h" = x""yes; then

:

else

{ { $as_echo "$as_me:$LINENO: error: pthread.h not found, required for --enable-thread-safety" >&5

$as_echo "$as_me: error: pthread.h not found, required for --enable-thread-safety" >&2;}

{ { $as_echo "$as_me:$LINENO: error:

pthread.h not found; use --disable-thread-safety to disable thread safety" >&5

$as_echo "$as_me: error:

pthread.h not found; use --disable-thread-safety to disable thread safety" >&2;}

{ (exit 1); exit 1; }; }

fi

if test "$pgac_cv_func_posix_signals" != yes -a "$enable_thread_safety" = yes; then

{ { $as_echo "$as_me:$LINENO: error:

Thread-safety requires POSIX signals, which are not supported by this

operating system." >&5

operating system; use --disable-thread-safety to disable thread safety." >&5

$as_echo "$as_me: error:

Thread-safety requires POSIX signals, which are not supported by this

operating system." >&2;}

operating system; use --disable-thread-safety to disable thread safety." >&2;}

{ (exit 1); exit 1; }; }

fi

fi

# We have to run the thread test near the end so we have all our symbols

# defined. Cross compiling throws a warning.

#

if test "$enable_thread_safety_force" = yes; then

if test "$PORTNAME" != "win32"

then

{ $as_echo "$as_me:$LINENO: WARNING:

*** Skipping thread test program. --enable-thread-safety-force was used.

*** Run the program in src/test/thread on the your machine and add proper

*** locking function calls to your applications to guarantee thread safety.

" >&5

$as_echo "$as_me: WARNING:

*** Skipping thread test program. --enable-thread-safety-force was used.

*** Run the program in src/test/thread on the your machine and add proper

*** locking function calls to your applications to guarantee thread safety.

" >&2;}

else

{ $as_echo "$as_me:$LINENO: WARNING: *** skipping thread test on Win32" >&5

$as_echo "$as_me: WARNING: *** skipping thread test on Win32" >&2;}

fi

elif test "$enable_thread_safety" = yes; then

if test "$enable_thread_safety" = yes; then

if test "$PORTNAME" != "win32"

then

{ $as_echo "$as_me:$LINENO: checking thread safety of required library functions" >&5

{ $as_echo "$as_me:$LINENO: result: no" >&5

$as_echo "no" >&6; }

{ { $as_echo "$as_me:$LINENO: error: thread test program failed

This platform is not thread-safe. Check the file 'config.log' for the

exact reason.

You can use the configure option --enable-thread-safety-force to force

threads to be enabled. But you must then run the program in

src/test/thread and add locking function calls to your applications to

guarantee thread safety." >&5

This platform is not thread-safe. Check the file 'config.log' or compile

and run src/test/thread/thread_test for the exact reason.

Use --disable-thread-safety to disable thread safety." >&5

$as_echo "$as_me: error: thread test program failed

This platform is not thread-safe. Check the file 'config.log' for the

exact reason.

You can use the configure option --enable-thread-safety-force to force

threads to be enabled. But you must then run the program in

src/test/thread and add locking function calls to your applications to

guarantee thread safety." >&2;}

This platform is not thread-safe. Check the file 'config.log' or compile

and run src/test/thread/thread_test for the exact reason.

Use --disable-thread-safety to disable thread safety." >&2;}

{ (exit 1); exit 1; }; }

fi

rm -rf conftest.dSYM

dnl Process this file with autoconf to produce a configure script.

dnl $PostgreSQL: pgsql/configure.in,v 1.614 2009/12/01 23:02:44 momjian Exp $

dnl $PostgreSQL: pgsql/configure.in,v 1.615 2009/12/02 14:07:25 momjian Exp $

dnl

dnl Developers, please strive to achieve this order:

dnl

# Enable thread-safe client libraries

#

AC_MSG_CHECKING([allow thread-safe client libraries])

PGAC_ARG_BOOL(enable, thread-safety, yes, [make client libraries thread-safe])

PGAC_ARG_BOOL(enable, thread-safety-force, no, [force thread-safety despite thread test failure])

if test "$enable_thread_safety" = yes -o \

"$enable_thread_safety_force" = yes; then

enable_thread_safety="yes"# for 'force'

AC_DEFINE([ENABLE_THREAD_SAFETY], 1,

[Define to 1 to build client libraries as thread-safe code. (--enable-thread-safety)])

fi

PGAC_ARG_BOOL(enable, thread-safety, yes, [disable thread-safety in client libraries])

AC_MSG_RESULT([$enable_thread_safety])

AC_SUBST(enable_thread_safety)

if test "$PTHREAD_CC" != "$CC"; then

AC_MSG_ERROR([

PostgreSQL does not support platforms that require a special compiler

for thread safety.])

for thread safety; use --disable-thread-safety to disable thread safety.])

fi

# Check for *_r functions

LIBS="$LIBS $PTHREAD_LIBS"

if test "$PORTNAME" != "win32"; then

AC_CHECK_HEADER(pthread.h, [], [AC_MSG_ERROR([pthread.h not found, required for --enable-thread-safety])])

AC_CHECK_HEADER(pthread.h, [], [AC_MSG_ERROR([

pthread.h not found; use --disable-thread-safety to disable thread safety])])

fi

AC_CHECK_FUNCS([strerror_r getpwuid_r gethostbyname_r])

if test "$pgac_cv_func_posix_signals" != yes -a "$enable_thread_safety" = yes; then

AC_MSG_ERROR([

Thread-safety requires POSIX signals, which are not supported by this

operating system.])

operating system; use --disable-thread-safety to disable thread safety.])

fi

fi

# We have to run the thread test near the end so we have all our symbols

# defined. Cross compiling throws a warning.

#

if test "$enable_thread_safety_force" = yes; then

if test "$PORTNAME" != "win32"

then

AC_MSG_WARN([

*** Skipping thread test program. --enable-thread-safety-force was used.

*** Run the program in src/test/thread on the your machine and add proper

*** locking function calls to your applications to guarantee thread safety.

])

else

AC_MSG_WARN([*** skipping thread test on Win32])

fi

elif test "$enable_thread_safety" = yes; then

if test "$enable_thread_safety" = yes; then

if test "$PORTNAME" != "win32"

then

AC_MSG_CHECKING([thread safety of required library functions])

[AC_MSG_RESULT(yes)],

[AC_MSG_RESULT(no)

AC_MSG_ERROR([thread test program failed

This platform is not thread-safe. Check the file 'config.log' for the

exact reason.

You can use the configure option --enable-thread-safety-force to force

threads to be enabled. But you must then run the program in

src/test/thread and add locking function calls to your applications to

guarantee thread safety.])],

This platform is not thread-safe. Check the file 'config.log' or compile

and run src/test/thread/thread_test for the exact reason.

Use --disable-thread-safety to disable thread safety.])],

[AC_MSG_RESULT(maybe)

AC_MSG_WARN([

*** Skipping thread test program because of cross-compile build.

<!-- $PostgreSQL: pgsql/doc/src/sgml/ecpg.sgml,v 1.92 2009/11/30 14:47:37 momjian Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/ecpg.sgml,v 1.93 2009/12/02 14:07:25 momjian Exp $ -->

<chapter id="ecpg">

<title><application>ECPG</application> - Embedded <acronym>SQL</acronym> in C</title>

</para>

<para>

The <application>ecpg</application> library is thread-safe if it is built

using the <option>--enable-thread-safety</> command-line option to

<filename>configure</filename>. (You might need to use other threading

command-line options to compile your client code.)

The <application>ecpg</application> library is thread-safe by

default. However, you might need to use some threading

command-line options to compile your client code.

</para>

</sect1>

<!-- $PostgreSQL: pgsql/doc/src/sgml/installation.sgml,v 1.327 2009/08/12 16:32:35 petere Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/installation.sgml,v 1.328 2009/12/02 14:07:25 momjian Exp $ -->

<chapter id="installation">

<title><![%standalone-include[<productname>PostgreSQL</>]]>

</varlistentry>

<varlistentry>

<term><option>--enable-thread-safety</option></term>

<term><option>--disable-thread-safety</option></term>

<listitem>

<para>

Make the client libraries thread-safe. Thisallows

Disable thethread-safety ofclient libraries. Thisprevents

concurrent threads in <application>libpq</application> and

<application>ECPG</application> programs to safely control

their private connection handles. This option requires adequate

threading support in your operating system.

<application>ECPG</application> programs from safely controlling

their private connection handles.

</para>

</listitem>

</varlistentry>

</sect3>

<sect3>

<title><option>--enable-thread-safety</option> and UnixWare</title>

<title>Threading on UnixWare</title>

<para>

If you use the <command>configure</command>

option <option>--enable-thread-safety</option>,

you <emphasis>must</emphasis> use <option>-Kpthread</option>

For threading, you<emphasis>must</emphasis> use <option>-Kpthread</option>

on <emphasis>all</emphasis> libpq-using programs. libpq

uses <function>pthread_*</function> calls, which are only

available with the

<!-- $PostgreSQL: pgsql/doc/src/sgml/libpq.sgml,v 1.291 2009/12/0204:54:10 tgl Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/libpq.sgml,v 1.292 2009/12/0214:07:25 momjian Exp $ -->

<chapter id="libpq">

<title><application>libpq</application> - C Library</title>

</indexterm>

<para>

<application>libpq</application> is reentrant and thread-safe if the

<filename>configure</filename> command-line option

<literal>--enable-thread-safety</> was used when the

<productname>PostgreSQL</productname> distribution was built. In

addition, you might need to use additional compiler command-line

<application>libpq</application> is reentrant and thread-safe by default.

You might need to use special compiler command-line

options when you compile your application code. Refer to your

system's documentation for information about how to build

thread-enabled applications, or look in

$PostgreSQL: pgsql/src/test/thread/README,v 1.2 2008/03/21 13:23:29 momjian Exp $

$PostgreSQL: pgsql/src/test/thread/README,v 1.3 2009/12/02 14:07:26 momjian Exp $

Threading

=========

This programshould berun bydevelopers wishingtoenablethreadingon

new platforms.

This programisrun byconfiguretodetermine ifthreadingis

properly supported on the platform.

Run thread_test program to determine if your native libc functions are

thread-safe, or if we should use *_r functions or thread locking.

You can run the program manually to see details, which shows if your

native libc functions are thread-safe, or if we use *_r functions or

thread locking.

To use this program, you must:

To use this program manually, you must:

o run "configure --enable-thread-safety"

o run "configure"

o compile the main source tree

o compile and run this program