Coro/Coro/Makefile.PL

use strict;
use ExtUtils::MakeMaker;
use Config;

$|=1;

my $DEFINE;
my @LIBS = [];

my $threads = $Config{usethreads};

sub have_inc($) {
   scalar grep -r "$_/$_[0]", $Config{usrinc}, split / /, $Config{incpth}
}

use Config;

print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

Coro has a number of configuration options. Due to its maturity, the
defaults that Coro chooses are usually fine, so you can decide to skip
these questions. Only if something went wrong you should select 'n'
here and manually configure Coro, and, of course, report this to the
maintainer :)

EOF

if (prompt ("Skip further questions and use defaults (y/n)?", "y") =~ /[yY]/) {
   $ENV{PERL_MM_USE_DEFAULT} = 1;
}


my $iface;

# default to assembly on x86 and x86_64 sometimes
my $iface_asm = $Config{archname} =~ /^(i[3456]86|amd64|x86_64)-/ ? "a" : undef;

# detect whether this perl is threaded, for those broken operating
# systems that need it.

my $pthread = $Config{libs} =~ /-lpthread/
           || $Config{ldflags} =~ /-pthread/
           || $Config{archname} =~ /-thread/;

if (exists $ENV{CORO_INTERFACE}) {
   $iface = $ENV{CORO_INTERFACE};

} elsif ($^O =~ /mswin32/i) {
   # nothing works, really, without deep hacks
   $iface = "f";

} elsif ($^O =~ /cygwin/) {
   # cygwin true to its form, be an order of magnitutde slower,
   # while using twice the amount of ram. but it works! yeah!
   $iface = "p";

} elsif ($^O =~ /irix/) {
   # sigaltstack works like sigstack, i.e. expects stack pointer, not stack base
   # but wikipeida lists it as 100% posix compliant. geeeee.
   $iface = "i";

} elsif ($^O =~ /linux/) {
   # everything "just works", as expected
   $iface = $iface_asm || "s";

} elsif ($^O =~ /freebsd/) {
   # FreeBSD 4.x has ucontext.h but no makecontext et al. (see BUGS section of
   # man context).
   #
   # FreeBSD 6.2 has marginally working ucontext, setjmp and asm, but
   # some 5.8.8's barf when threaded due to broken threading.

   $iface = $iface_asm || "s";

} elsif ($^O =~ /netbsd/) {
   # netbsd is totally broken (pthreads are incompatible with ucontext or
   # other stack switching mechanisms) therefore, default to pthread -
   # hey, it might actually work, with some hacks.
   $iface = "p";

   if (!$pthread) {
      # uh-oh
      print <<EOF;

***
*** WARNING: Your platform is known to have broken pthreads, which are
*** required for Coro because your platform is known to have broken
*** ucontext and setjmp/longjmp functions as well, which are broken
*** because your pthread library is broken. D'oh.
***
*** Coro will try to fight this vicious circle of breakage, but YMMV. If
*** Coro fails, try to recompile your perl with -lpthread, which will work
*** around some of the pthread bugs. (You do not have to enable ithreads).
***

EOF
      # ugh, pthreads need to be linked into the main program :/
      $iface = $iface_asm || "s";
   }

} elsif ($^O =~ /(openbsd|mirbsd)/) {
   # mirbsd seems to be bug-to-bug compatible openbsd fork,
   # with the name change being the biggest difference.
   if (!$pthread) {
      # asm seems to work, setjmp might, ucontext is missing,
      # threads lets not talk about
      # try setjmp/longjmp on 4.4, but pthread on earlier
      $iface = $iface_asm || ($Config{osvers} >= 4.4 ? "s" : "p");
   } else {
      # seems newer openbsd platforms have marginally working pthreads, but
      # their pthreads break sigaltstack - reading the sigaltstack sources
      # again shows how fundamentally clueless those people are (if no thread
      # has ever been created, then the program is bound to a kernel-scheduled
      # entity. get that? GET THAT?)
      $iface = "p";
   }

} elsif ($^O =~ /solaris/) {
   # setjmp, ucontext seem to work, as well as asm
   $iface = $iface_asm || "s";

} elsif ($^O =~ /darwin/) {
   # assembler doesn't support .type
   # ucontext is of course totally broken (it just crashes)
   # surprisingly, pthreads seem to work
   $iface = "s";

} elsif ($^O =~ /dragonfly/) {
   # ucontext is totally broken on dragonfly bsd:
   # Fatal error 'siglongjmp()ing between thread contexts is undefined by POSIX 1003.1
   $iface = "s";

} elsif (have_inc "ucontext.h") { # shame on this heuristic
   $iface = "u";

} else {
   $iface = "s";
}

print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

Coro can use a number of methods to implement coroutines at the C
level. The default chosen is based on your current confguration and is
correct in most cases, but you still can chose between these alternatives:

u  The unix 'ucontext.h' functions are relatively new and not implemented
   or well-tested in older unices. They allow very fast coroutine creation
   and reasonably fast switching. They are, however, usually slower than
   the other alternatives due to an extra syscall done by swapcontext. And
   while nominally most portable (it's the only POSIX-standardised
   interface for coroutines), ucontext functions are, as usual, broken on
   most/all BSDs.

s  If the ucontext functions are not working or you don't want
   to use them for other reasons you can try a workaround using
   setjmp/longjmp/sigaltstack (also standard unix functions). Coroutine
   creation is rather slow, but switching is very fast (often much faster
   than with the ucontext functions). Unfortunately, glibc-2.1 and
   below don't even feature a working sigaltstack. You cannot use this
   implementation if some other code uses SIGUSR2 or you plan to create
   coroutines from an alternative signal stack, as both are being used for
   coroutine creation.

a  Handcoded assembly. This is the fastest and most compatible method,
   with the least side effects, if it works, that is. It has been tested
   on GNU/Linux x86 and x86_64 systems and should work on all x86/x86_64
   systems using the SVR ELF ABI (it is also reported to be working on
   Strawberry Perl for Windows using MinGW). This is the recommended
   method on supported platforms. When it doesn't work, use another
   method, such as (s)etjmp/longjmp.

l  GNU/Linux. Very old GNU/Linux systems (glibc-2.1 and below) need
   this hack. Since it is very linux-specific it is also quite fast and
   recommended even for newer versions; when it works, that is (currently
   x86 and a few others only. If it compiles, it's usually ok). Newer
   glibc versions (>= 2.5) stop working with this implementation however.

i  IRIX. For some reason, SGI really does not like to follow POSIX (does
   that surprise you?), so this workaround might be needed (it's fast),
   although [s] and [u] should also work now.

w  Microsoft Windows. Try this on Microsoft Windows when using Cygwin or
   the MSVC compilers (e.g. ActiveState Perl, but see "a" for Strawberry
   Perl), although, as there is no standard on how to do this under
   windows, different environments might work differently. Doh.

f  Microsoft Windows. Try this on Microsoft Windows if w fails. It is slower
   and uses a lot more memory, but should be working all the time.

p  Use pthread API. Try to avoid this option, it was only created to
   make a point about the programming language shootout. It is unlikely
   to work with perls that have windows process emulation enabled ("perl
   threads"). It is also likely the slowest method of implementing
   coroutines. It might work fine as a last resort, however, as the
   pthread API is slightly better tested than ucontext functions for
   example. Of course, not on BSDs, who usually have very broken pthread
   implementations.

Coro tries hard to come up with a suitable default for most systems,
so pressing return at the prompt usually does the right thing. If you
experience problems (e.g. make test fails) then you should experiment with
this setting.

EOF

retry:

my $r = prompt "Use which implementation,\n" .
               "<s>etjmp, <u>ctx, <a>sm, <i>rix, <l>inux, <p>threads, <w>indows, <f>iber?",
               $iface;
$iface = lc $1 if $r =~ /(\S)/;

if ($iface eq "u") {
   $DEFINE .= " -DCORO_UCONTEXT";
   print "\nUsing ucontext implementation\n\n";
   conftest ("TEST_makecontext");
} elsif ($iface eq "s") {
   $DEFINE .= " -D_FORTIFY_SOURCE=0";
   $DEFINE .= " -DCORO_SJLJ";
   print "\nUsing setjmp/longjmp/sigaltstack implementation\n\n";
   conftest ("TEST_sigaltstack");
} elsif ($iface eq "l") {
   $DEFINE .= " -DCORO_LINUX";
   print "\nUsing linux-specific implementation\n\n";
} elsif ($iface eq "i") {
   $DEFINE .= " -DCORO_IRIX";
   print "\nUsing irix-specific implementation\n\n";
} elsif ($iface eq "w") {
   $DEFINE .= " -DCORO_LOSER";
   print "\nUsing windows-specific implementation\n\n";
} elsif ($iface eq "f") {
   $DEFINE .= " -DCORO_FIBER";
   print "\nUsing windows-specific fiber implementation\n\n";
} elsif ($iface eq "a") {
   $DEFINE .= " -DCORO_ASM";
   print "\nUsing handcoded assembler implementation\n\n";
} elsif ($iface eq "p") {
   $DEFINE .= " -DCORO_PTHREAD";
   @LIBS = ["-lpthread"];
   print "\nUsing pthread implementation\n\n";
} else {
   print "\nUnknown implementation \"$iface\"\n";
   goto retry;
}

print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

Per-context stack size factor: Depending on your settings, Coro tries to
share the C stacks is creates as much as possible, but sometimes it needs
to allocate a new one. This setting controls the maximum size that gets
allocated, and should not be set too high, as memory and address space
still is wasted even if it's not fully used. The value entered will be
multiplied by sizeof(void *), which is usually 4 on 32-bit systems, and 8
on 64-bit systems.

A setting of 16384 (the default) therefore corresponds to a 64k..128k
stack, which usually is ample space (you might even want to try 8192 or
lower if your program creates many coroutines).

On systems supporting mmap and dynamic memory management, the actual
memory usually gets allocated on demand, but with many large stacks you
can still run out of address space on your typical 32 bit platform (not to
forget the pagetables).

Some perls (mostly threaded ones and perl compiled under linux 2.6) and
some programs (inefficient regexes can use a lot of stack space) may
need much, much more: If Coro segfaults with weird backtraces (e.g. in a
function prologue) or in t/10_bugs.t, you might want to increase this to
65536 or more.

The default should be fine, and can be changed at runtime with
Coro::State::cctx_stacksize.

EOF

my $stacksize = $^O eq "linux" && $] < 5.008008 ? 128 * 1024 : 16384;

$stacksize = prompt ("C stack size factor?", $stacksize);
$DEFINE .= " -DCORO_STACKSIZE=$stacksize";

print "using a stacksize of $stacksize * sizeof(void*)\n";

print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

Coro can optionally put a guard area before each stack segment: When the
stack is too small and the access is not too far outside the stack (i.e.
within the guard area), then the program will safely segfault instead of
running into other data. The cost is some additional overhead with is
usually negligible, and extra use of address space.

The guard area size currently needs to be specified in pages (typical
pagesizes are 4k and 8k). The guard area is only enabled on a few
hardcoded architectures and is ignored on others. The actual preprocessor
expression disables this feature if:

   !__i386 && !__x86_64 && !__powerpc && !__m68k \
   && !__alpha && !__mips && !__sparc64

The default, as usual, should be just fine.

EOF

my $guardpages = $^O eq "minix" ? "0" : "4";
$guardpages = prompt ("Number of guard pages (0 disables)?", $guardpages);
$DEFINE .= " -DCORO_GUARDPAGES=$guardpages";

print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

Coro can tell valgrind about its stacks and so reduce spurious warnings
where valgrind would otherwise complain about possible stack switches.

Enabling this does not incur noticable runtime or memory overhead, but it
requires that you have the <valgrind/valgrind.h> header file available.

Valgrind support is completely optional, so disabling it is the safe
choice.

EOF

my $valgrind = have_inc "valgrind/valgrind.h" ?  "y" : "n";
$valgrind = $ENV{CORO_USE_VALGRIND} if exists $ENV{CORO_USE_VALGRIND};
$valgrind = prompt ("Enable valgrind support (y/n)?", $valgrind);
$DEFINE .= " -DCORO_USE_VALGRIND=1" if $valgrind =~ /[yY]/;


print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

Coro can use (or even trick) some perl functions into doing what it needs
instead of relying on (some) of its own functions. This might increase
chances that it compiles and works, but it could just as well result in
memory leaks, crashes or silent data corruption. It certainly does result
in slightly slower speed and higher memory consumption, though, so YOU
SHOULD ENABLE THIS OPTION ONLY AS A LAST RESORT.

EOF

my $use_internals = prompt ("Prefer perl functions over coro functions (y/n)?", "n");
$DEFINE .= " -DCORO_PREFER_PERL_FUNCTIONS=1" if $use_internals =~ /[yY]/;

print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

Coro can use a simple JIT compiler to compile a part of the thread switch
function at runtime. On perls with windows process emulation (most!),
this results in a 50% speed improvement. On sane perls, the gain is much
less, usually around 5%. If you enable this option, then the JIT will
be enabled, on compatible operating systems and CPUs (currently only
x86/amd64 on certain unix clones). Otherwise, it will be disabled. It
should be safe to leave on - this setting is only here so you can switch
it off in case of problems.

Note that some broken kernels (often calling themselves "hardened") break
all JIT generation by manipulating some system calls. If you get bus
errors or segmentation faults immediately when the JIT is enabled but not
without, then note that disabling the JIT only fixes some symptoms, not
the underlying problem, and you might run into other problems later.

EOF

my $orgasm = $ENV{CORO_JIT} || "y";
$orgasm = prompt ("Try to use the JIT compiler, if available?", $orgasm);
$DEFINE .= " -DCORO_JIT=1" if $orgasm =~ /[yY]/;

print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

Coro has experimental support for cloning states. This can be used
to implement a scheme-like call/cc. However, this doesn't add to the
expressiveness in general, and is likely perl-version specific (and perl
5.12 deliberately removed support for it). As such, it is disabled by
default.  Enable it when you want to play around with it, but note that it
isn't supported, and unlikely ever will be. It exists mainly to prove that
it could be done - if only it were useful for something.

EOF

my $masturbate = $ENV{CORO_CLONE} || "n";
$masturbate = prompt ("Implement Coro::State->clone method (y/n)?", $masturbate);
$DEFINE .= " -DCORO_CLONE=1" if $masturbate =~ /[yY]/;

print <<EOF;

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***

EOF

WriteMakefile(
  NAME         => "Coro::State",
  VERSION_FROM => "State.pm",
  DEFINE       => $DEFINE,
  LIBS         => @LIBS,
  DIR          => [],
  depend => {
     "State.c" => "state.h clone.c ecb.h libcoro/coro.h libcoro/coro.c",
  },
);

sub conftest {
   my $type = shift;

   print "\nTrying to detect stack growth direction (for $type)\n";
   print "You might see some warnings, this should not concern you.\n\n";
   system "$Config{cc} $Config{ccflags} -D$type libcoro/conftest.c";

   my $res = qx<./a.out>;
   $res =~ s/\s+$//;
   my ($sp, $ss) = split /,/, $res;

   print "\n\n*****************************************************************************\n";
   print "If the testsuite fails PLEASE provide the following information\n";
   print "to Marc Lehmann <schmorp\@schmorp.de>: operating system name, version,\n";
   print "architecture name and this string '$sp|$ss'. Thanks a lot!\n";#d#
   print "*****************************************************************************\n\n";

   unlink "a.out";
   unlink "conftestval";
}

Revision:	1.91
Committed:	Fri Jul 12 06:33:33 2019 UTC (4 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-6_55, rel-6_56, rel-6_57, HEAD
Changes since 1.90:	+2 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.55	use strict;
2			use ExtUtils::MakeMaker;
3	root	1.2	use Config;
4
5	root	1.6	$\|=1;
6
7	root	1.55	my $DEFINE;
8			my @LIBS = [];
9	root	1.2
10	root	1.69	my $threads = $Config{usethreads};
11	root	1.57
12	root	1.89	sub have_inc($) {
13			scalar grep -r "$_/$_[0]", $Config{usrinc}, split / /, $Config{incpth}
14			}
15
16	root	1.75	use Config;
17
18	root	1.44	print <<EOF;
19
20	root	1.86	* * * * * * * * * * * * * * * * * *
21	root	1.44
22			Coro has a number of configuration options. Due to its maturity, the
23			defaults that Coro chooses are usually fine, so you can decide to skip
24			these questions. Only if something went wrong you should select 'n'
25			here and manually configure Coro, and, of course, report this to the
26			maintainer :)
27
28			EOF
29
30	root	1.45	if (prompt ("Skip further questions and use defaults (y/n)?", "y") =~ /[yY]/) {
31	root	1.44	$ENV{PERL_MM_USE_DEFAULT} = 1;
32			}
33
34
35	root	1.55	my $iface;
36
37	root	1.65	# default to assembly on x86 and x86_64 sometimes
38			my $iface_asm = $Config{archname} =~ /^(i[3456]86\|amd64\|x86_64)-/ ? "a" : undef;
39
40	root	1.83	# detect whether this perl is threaded, for those broken operating
41			# systems that need it.
42
43			my $pthread = $Config{libs} =~ /-lpthread/
44			\|\| $Config{ldflags} =~ /-pthread/
45			\|\| $Config{archname} =~ /-thread/;
46
47	root	1.49	if (exists $ENV{CORO_INTERFACE}) {
48			$iface = $ENV{CORO_INTERFACE};
49	root	1.50
50	root	1.84	} elsif ($^O =~ /mswin32/i) {
51	root	1.69	# nothing works, really, without deep hacks
52	root	1.86	$iface = "f";
53	root	1.50
54	root	1.84	} elsif ($^O =~ /cygwin/) {
55			# cygwin true to its form, be an order of magnitutde slower,
56	root	1.86	# while using twice the amount of ram. but it works! yeah!
57			$iface = "p";
58	root	1.84
59	root	1.14	} elsif ($^O =~ /irix/) {
60	root	1.69	# sigaltstack works like sigstack, i.e. expects stack pointer, not stack base
61			# but wikipeida lists it as 100% posix compliant. geeeee.
62	root	1.14	$iface = "i";
63	root	1.50
64	root	1.4	} elsif ($^O =~ /linux/) {
65	root	1.69	# everything "just works", as expected
66	root	1.65	$iface = $iface_asm \|\| "s";
67	root	1.48
68	root	1.65	} elsif ($^O =~ /freebsd/) {
69	root	1.40	# FreeBSD 4.x has ucontext.h but no makecontext et al. (see BUGS section of
70	root	1.69	# man context).
71	root	1.65	#
72	root	1.69	# FreeBSD 6.2 has marginally working ucontext, setjmp and asm, but
73	root	1.68	# some 5.8.8's barf when threaded due to broken threading.
74	root	1.65
75			$iface = $iface_asm \|\| "s";
76	root	1.50
77	root	1.65	} elsif ($^O =~ /netbsd/) {
78	root	1.75	# netbsd is totally broken (pthreads are incompatible with ucontext or
79	root	1.69	# other stack switching mechanisms) therefore, default to pthread -
80	root	1.75	# hey, it might actually work, with some hacks.
81	root	1.62	$iface = "p";
82	root	1.50
83	root	1.83	if (!$pthread) {
84	root	1.75	# uh-oh
85			print <<EOF;
86
87			***
88			*** WARNING: Your platform is known to have broken pthreads, which are
89			*** required for Coro because your platform is known to have broken
90			*** ucontext and setjmp/longjmp functions as well, which are broken
91			*** because your pthread library is broken. D'oh.
92			***
93			*** Coro will try to fight this vicious circle of breakage, but YMMV. If
94			*** Coro fails, try to recompile your perl with -lpthread, which will work
95			*** around some of the pthread bugs. (You do not have to enable ithreads).
96			***
97
98			EOF
99			# ugh, pthreads need to be linked into the main program :/
100			$iface = $iface_asm \|\| "s";
101			}
102
103	root	1.73	} elsif ($^O =~ /(openbsd\|mirbsd)/) {
104	root	1.81	# mirbsd seems to be bug-to-bug compatible openbsd fork,
105	root	1.73	# with the name change being the biggest difference.
106	root	1.83	if (!$pthread) {
107	root	1.82	# asm seems to work, setjmp might, ucontext is missing,
108			# threads lets not talk about
109	root	1.81	# try setjmp/longjmp on 4.4, but pthread on earlier
110			$iface = $iface_asm \|\| ($Config{osvers} >= 4.4 ? "s" : "p");
111			} else {
112			# seems newer openbsd platforms have marginally working pthreads, but
113			# their pthreads break sigaltstack - reading the sigaltstack sources
114			# again shows how fundamentally clueless those people are (if no thread
115			# has ever been created, then the program is bound to a kernel-scheduled
116			# entity. get that? GET THAT?)
117			$iface = "p";
118			}
119	root	1.71
120	root	1.8	} elsif ($^O =~ /solaris/) {
121	root	1.66	# setjmp, ucontext seem to work, as well as asm
122			$iface = $iface_asm \|\| "s";
123	root	1.50
124	root	1.25	} elsif ($^O =~ /darwin/) {
125	root	1.69	# assembler doesn't support .type
126			# ucontext is of course totally broken (it just crashes)
127			# surprisingly, pthreads seem to work
128	root	1.25	$iface = "s";
129	root	1.50
130	root	1.60	} elsif ($^O =~ /dragonfly/) {
131			# ucontext is totally broken on dragonfly bsd:
132			# Fatal error 'siglongjmp()ing between thread contexts is undefined by POSIX 1003.1
133			$iface = "s";
134
135	root	1.89	} elsif (have_inc "ucontext.h") { # shame on this heuristic
136	root	1.3	$iface = "u";
137	root	1.50
138	root	1.2	} else {
139	root	1.3	$iface = "s";
140	root	1.2	}
141
142	root	1.44	print <<EOF;
143	root	1.2
144	root	1.87	* * * * * * * * * * * * * * * * * *
145	root	1.38
146	root	1.40	Coro can use a number of methods to implement coroutines at the C
147			level. The default chosen is based on your current confguration and is
148			correct in most cases, but you still can chose between these alternatives:
149	root	1.34
150			u The unix 'ucontext.h' functions are relatively new and not implemented
151	root	1.48	or well-tested in older unices. They allow very fast coroutine creation
152	root	1.78	and reasonably fast switching. They are, however, usually slower than
153	root	1.63	the other alternatives due to an extra syscall done by swapcontext. And
154			while nominally most portable (it's the only POSIX-standardised
155			interface for coroutines), ucontext functions are, as usual, broken on
156			most/all BSDs.
157	root	1.4
158			s If the ucontext functions are not working or you don't want
159	root	1.48	to use them for other reasons you can try a workaround using
160			setjmp/longjmp/sigaltstack (also standard unix functions). Coroutine
161	root	1.49	creation is rather slow, but switching is very fast (often much faster
162			than with the ucontext functions). Unfortunately, glibc-2.1 and
163			below don't even feature a working sigaltstack. You cannot use this
164	root	1.63	implementation if some other code uses SIGUSR2 or you plan to create
165			coroutines from an alternative signal stack, as both are being used for
166			coroutine creation.
167	root	1.49
168	root	1.63	a Handcoded assembly. This is the fastest and most compatible method,
169	root	1.53	with the least side effects, if it works, that is. It has been tested
170			on GNU/Linux x86 and x86_64 systems and should work on all x86/x86_64
171	root	1.56	systems using the SVR ELF ABI (it is also reported to be working on
172			Strawberry Perl for Windows using MinGW). This is the recommended
173	root	1.63	method on supported platforms. When it doesn't work, use another
174			method, such as (s)etjmp/longjmp.
175	root	1.4
176	root	1.38	l GNU/Linux. Very old GNU/Linux systems (glibc-2.1 and below) need
177	root	1.48	this hack. Since it is very linux-specific it is also quite fast and
178			recommended even for newer versions; when it works, that is (currently
179			x86 and a few others only. If it compiles, it's usually ok). Newer
180	root	1.63	glibc versions (>= 2.5) stop working with this implementation however.
181	root	1.14
182	root	1.63	i IRIX. For some reason, SGI really does not like to follow POSIX (does
183			that surprise you?), so this workaround might be needed (it's fast),
184			although [s] and [u] should also work now.
185	root	1.2
186	root	1.56	w Microsoft Windows. Try this on Microsoft Windows when using Cygwin or
187			the MSVC compilers (e.g. ActiveState Perl, but see "a" for Strawberry
188			Perl), although, as there is no standard on how to do this under
189	root	1.58	windows, different environments might work differently. Doh.
190	root	1.34
191	root	1.86	f Microsoft Windows. Try this on Microsoft Windows if w fails. It is slower
192			and uses a lot more memory, but should be working all the time.
193
194	root	1.64	p Use pthread API. Try to avoid this option, it was only created to
195			make a point about the programming language shootout. It is unlikely
196			to work with perls that have windows process emulation enabled ("perl
197			threads"). It is also likely the slowest method of implementing
198			coroutines. It might work fine as a last resort, however, as the
199			pthread API is slightly better tested than ucontext functions for
200			example. Of course, not on BSDs, who usually have very broken pthread
201			implementations.
202	root	1.63
203			Coro tries hard to come up with a suitable default for most systems,
204			so pressing return at the prompt usually does the right thing. If you
205			experience problems (e.g. make test fails) then you should experiment with
206			this setting.
207	root	1.28
208	root	1.2	EOF
209	root	1.3
210			retry:
211	root	1.14
212	root	1.44	my $r = prompt "Use which implementation,\n" .
213	root	1.86	"<s>etjmp, <u>ctx, <a>sm, <i>rix, <l>inux, <p>threads, <w>indows, <f>iber?",
214	root	1.44	$iface;
215			$iface = lc $1 if $r =~ /(\S)/;
216
217			if ($iface eq "u") {
218			$DEFINE .= " -DCORO_UCONTEXT";
219			print "\nUsing ucontext implementation\n\n";
220	root	1.58	conftest ("TEST_makecontext");
221	root	1.44	} elsif ($iface eq "s") {
222	root	1.90	$DEFINE .= " -D_FORTIFY_SOURCE=0";
223	root	1.44	$DEFINE .= " -DCORO_SJLJ";
224			print "\nUsing setjmp/longjmp/sigaltstack implementation\n\n";
225	root	1.58	conftest ("TEST_sigaltstack");
226	root	1.44	} elsif ($iface eq "l") {
227			$DEFINE .= " -DCORO_LINUX";
228			print "\nUsing linux-specific implementation\n\n";
229			} elsif ($iface eq "i") {
230			$DEFINE .= " -DCORO_IRIX";
231			print "\nUsing irix-specific implementation\n\n";
232			} elsif ($iface eq "w") {
233			$DEFINE .= " -DCORO_LOSER";
234			print "\nUsing windows-specific implementation\n\n";
235	root	1.86	} elsif ($iface eq "f") {
236			$DEFINE .= " -DCORO_FIBER";
237			print "\nUsing windows-specific fiber implementation\n\n";
238	root	1.49	} elsif ($iface eq "a") {
239			$DEFINE .= " -DCORO_ASM";
240	root	1.75	print "\nUsing handcoded assembler implementation\n\n";
241	root	1.55	} elsif ($iface eq "p") {
242			$DEFINE .= " -DCORO_PTHREAD";
243			@LIBS = ["-lpthread"];
244			print "\nUsing pthread implementation\n\n";
245	root	1.3	} else {
246	root	1.44	print "\nUnknown implementation \"$iface\"\n";
247			goto retry;
248	root	1.3	}
249	root	1.2
250	root	1.36	print <<EOF;
251
252	root	1.87	* * * * * * * * * * * * * * * * * *
253	root	1.38
254			Per-context stack size factor: Depending on your settings, Coro tries to
255	root	1.58	share the C stacks is creates as much as possible, but sometimes it needs
256			to allocate a new one. This setting controls the maximum size that gets
257			allocated, and should not be set too high, as memory and address space
258			still is wasted even if it's not fully used. The value entered will be
259	root	1.87	multiplied by sizeof(void *), which is usually 4 on 32-bit systems, and 8
260			on 64-bit systems.
261	root	1.37
262	root	1.38	A setting of 16384 (the default) therefore corresponds to a 64k..128k
263	root	1.40	stack, which usually is ample space (you might even want to try 8192 or
264	root	1.38	lower if your program creates many coroutines).
265	root	1.37
266	root	1.41	On systems supporting mmap and dynamic memory management, the actual
267			memory usually gets allocated on demand, but with many large stacks you
268	root	1.58	can still run out of address space on your typical 32 bit platform (not to
269			forget the pagetables).
270	root	1.41
271	root	1.40	Some perls (mostly threaded ones and perl compiled under linux 2.6) and
272			some programs (inefficient regexes can use a lot of stack space) may
273			need much, much more: If Coro segfaults with weird backtraces (e.g. in a
274			function prologue) or in t/10_bugs.t, you might want to increase this to
275			65536 or more.
276	root	1.36
277	root	1.47	The default should be fine, and can be changed at runtime with
278			Coro::State::cctx_stacksize.
279	root	1.41
280	root	1.36	EOF
281
282	root	1.67	my $stacksize = $^O eq "linux" && $] < 5.008008 ? 128 * 1024 : 16384;
283
284			$stacksize = prompt ("C stack size factor?", $stacksize);
285	root	1.46	$DEFINE .= " -DCORO_STACKSIZE=$stacksize";
286	root	1.36
287	root	1.87	print "using a stacksize of $stacksize * sizeof(void*)\n";
288	root	1.36
289	root	1.38	print <<EOF;
290
291	root	1.87	* * * * * * * * * * * * * * * * * *
292	root	1.38
293	root	1.58	Coro can optionally put a guard area before each stack segment: When the
294	root	1.41	stack is too small and the access is not too far outside the stack (i.e.
295			within the guard area), then the program will safely segfault instead of
296			running into other data. The cost is some additional overhead with is
297			usually negligible, and extra use of address space.
298
299			The guard area size currently needs to be specified in pages (typical
300			pagesizes are 4k and 8k). The guard area is only enabled on a few
301			hardcoded architectures and is ignored on others. The actual preprocessor
302			expression disables this feature if:
303
304			!__i386 && !__x86_64 && !__powerpc && !__m68k \
305			&& !__alpha && !__mips && !__sparc64
306
307			The default, as usual, should be just fine.
308
309			EOF
310
311	root	1.91	my $guardpages = $^O eq "minix" ? "0" : "4";
312			$guardpages = prompt ("Number of guard pages (0 disables)?", $guardpages);
313	root	1.87	$DEFINE .= " -DCORO_GUARDPAGES=$guardpages";
314	root	1.41
315			print <<EOF;
316
317	root	1.87	* * * * * * * * * * * * * * * * * *
318	root	1.41
319	root	1.43	Coro can tell valgrind about its stacks and so reduce spurious warnings
320			where valgrind would otherwise complain about possible stack switches.
321
322	root	1.58	Enabling this does not incur noticable runtime or memory overhead, but it
323	root	1.43	requires that you have the <valgrind/valgrind.h> header file available.
324
325	root	1.58	Valgrind support is completely optional, so disabling it is the safe
326			choice.
327	root	1.43
328			EOF
329
330	root	1.89	my $valgrind = have_inc "valgrind/valgrind.h" ? "y" : "n";
331	root	1.88	$valgrind = $ENV{CORO_USE_VALGRIND} if exists $ENV{CORO_USE_VALGRIND};
332			$valgrind = prompt ("Enable valgrind support (y/n)?", $valgrind);
333	root	1.46	$DEFINE .= " -DCORO_USE_VALGRIND=1" if $valgrind =~ /[yY]/;
334	root	1.43
335	root	1.44
336			print <<EOF;
337
338	root	1.87	* * * * * * * * * * * * * * * * * *
339	root	1.44
340			Coro can use (or even trick) some perl functions into doing what it needs
341			instead of relying on (some) of its own functions. This might increase
342			chances that it compiles and works, but it could just as well result in
343			memory leaks, crashes or silent data corruption. It certainly does result
344	root	1.51	in slightly slower speed and higher memory consumption, though, so YOU
345	root	1.58	SHOULD ENABLE THIS OPTION ONLY AS A LAST RESORT.
346	root	1.44
347			EOF
348
349	root	1.45	my $use_internals = prompt ("Prefer perl functions over coro functions (y/n)?", "n");
350	root	1.46	$DEFINE .= " -DCORO_PREFER_PERL_FUNCTIONS=1" if $use_internals =~ /[yY]/;
351	root	1.44
352	root	1.43	print <<EOF;
353
354	root	1.87	* * * * * * * * * * * * * * * * * *
355	root	1.43
356	root	1.78	Coro can use a simple JIT compiler to compile a part of the thread switch
357	root	1.79	function at runtime. On perls with windows process emulation (most!),
358			this results in a 50% speed improvement. On sane perls, the gain is much
359	root	1.80	less, usually around 5%. If you enable this option, then the JIT will
360			be enabled, on compatible operating systems and CPUs (currently only
361			x86/amd64 on certain unix clones). Otherwise, it will be disabled. It
362			should be safe to leave on - this setting is only here so you can switch
363			it off in case of problems.
364	root	1.78
365	root	1.85	Note that some broken kernels (often calling themselves "hardened") break
366			all JIT generation by manipulating some system calls. If you get bus
367			errors or segmentation faults immediately when the JIT is enabled but not
368			without, then note that disabling the JIT only fixes some symptoms, not
369			the underlying problem, and you might run into other problems later.
370
371	root	1.78	EOF
372
373			my $orgasm = $ENV{CORO_JIT} \|\| "y";
374			$orgasm = prompt ("Try to use the JIT compiler, if available?", $orgasm);
375			$DEFINE .= " -DCORO_JIT=1" if $orgasm =~ /[yY]/;
376
377			print <<EOF;
378
379	root	1.87	* * * * * * * * * * * * * * * * * *
380	root	1.78
381	root	1.70	Coro has experimental support for cloning states. This can be used
382			to implement a scheme-like call/cc. However, this doesn't add to the
383	root	1.76	expressiveness in general, and is likely perl-version specific (and perl
384			5.12 deliberately removed support for it). As such, it is disabled by
385			default. Enable it when you want to play around with it, but note that it
386			isn't supported, and unlikely ever will be. It exists mainly to prove that
387			it could be done - if only it were useful for something.
388	root	1.70
389			EOF
390
391			my $masturbate = $ENV{CORO_CLONE} \|\| "n";
392			$masturbate = prompt ("Implement Coro::State->clone method (y/n)?", $masturbate);
393			$DEFINE .= " -DCORO_CLONE=1" if $masturbate =~ /[yY]/;
394
395			print <<EOF;
396
397	root	1.87	* * * * * * * * * * * * * * * * * *
398	root	1.70
399	root	1.38	EOF
400	root	1.36
401	root	1.1	WriteMakefile(
402	root	1.2	NAME => "Coro::State",
403			VERSION_FROM => "State.pm",
404			DEFINE => $DEFINE,
405	root	1.55	LIBS => @LIBS,
406	root	1.2	DIR => [],
407	root	1.62	depend => {
408	root	1.78	"State.c" => "state.h clone.c ecb.h libcoro/coro.h libcoro/coro.c",
409	root	1.62	},
410	root	1.1	);
411	root	1.2
412	root	1.15	sub conftest {
413			my $type = shift;
414
415			print "\nTrying to detect stack growth direction (for $type)\n";
416			print "You might see some warnings, this should not concern you.\n\n";
417			system "$Config{cc} $Config{ccflags} -D$type libcoro/conftest.c";
418
419			my $res = qx<./a.out>;
420			$res =~ s/\s+$//;
421			my ($sp, $ss) = split /,/, $res;
422
423			print "\n\n*****************************************************************************\n";
424			print "If the testsuite fails PLEASE provide the following information\n";
425	root	1.32	print "to Marc Lehmann <schmorp\@schmorp.de>: operating system name, version,\n";
426	root	1.15	print "architecture name and this string '$sp\|$ss'. Thanks a lot!\n";#d#
427			print "*****************************************************************************\n\n";
428
429			unlink "a.out";
430	root	1.17	unlink "conftestval";
431	root	1.15	}
432	root	1.2