Coro/Coro/Makefile.PL

use 5.005;

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

$|=1;

my $DEFINE;
my @LIBS = [];

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;
}


$DEFINE .= " -DHAVE_MMAP" if $Config{d_mmap} eq "define" && $Config{d_munmap} eq "define";

my $iface;

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

} elsif ($^O =~ /win32/i or $^O =~ /cygwin/ or $^O =~ /mswin/) {
   $iface = 'w';

} elsif ($^O =~ /irix/) {
   $iface = "i";

} elsif ($^O =~ /linux/) {
   # default to assembly on x86 and x86_64, and setjmp on others
   $iface = $Config{archname} =~ /^(i[3456]86|amd64|x86_64)-/ && $Config{optimize} =~ /-O/ ? "a" : "s";

} elsif ($^O =~ /(free|net|open)bsd/) {
   # FreeBSD 4.x has ucontext.h but no makecontext et al. (see BUGS section of
   # man context). Assume the same problem for all other BSDs.

   # default to assembly on x86 and x86_64, and setjmp on others
   $iface = $Config{archname} =~ /^(i[3456]86|amd64|x86_64)-/ && $Config{optimize} =~ /-O/ ? "a" : "s";

} elsif ($^O =~ /solaris/) {
   $iface = "s";

} elsif ($^O =~ /darwin/) {
   $iface = "s";

} elsif (-e "/usr/include/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, and, most importantly, are very stable.
   It is, however, usually slower than the other alternatives due to an
   extra syscall done by swapcontext.

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. Note that you usually have to compile
   this module with optimisation enabled for this method to work, and
   also more esoteric switches such as -fomit-leaf-frame-pointer might be
   required. When i doubt, 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 again.

i  IRIX. For some reason, SGI really does not like to follow the single
   unix specification (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 enviroments might work differently. Doh.

p  Use pthread API. Try to avoid this option, it was only created to make
   a point about the programming language shootout and might leak threads.
   It might work fine as a last resort, however.

For most systems, the default chosen should be OK. If you experience
problems then you should experiment with this setting and/or turn
optimisations on or off (make OPTIMIZE=-O0).

EOF

retry:

my $r = prompt "Use which implementation,\n" .
               "<s>et/longjump, <u>context, <a>ssembly, <i>rix, <l>inux or <w>indows?",
               $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 .= " -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 "a") {
   $DEFINE .= " -DCORO_ASM";
   print "\nUsing handcoded assembly 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 stack 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(long), 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.

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 = prompt ("C stack size factor?", "16384");
$DEFINE .= " -DCORO_STACKSIZE=$stacksize";

print "using a stacksize of $stacksize * sizeof(long)\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 $stackguard = prompt ("Number of guard pages (0 disables)?", "4");
$DEFINE .= " -DCORO_STACKGUARD=$stackguard";

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 visible runtime or memory overhead, but it
requires that you have the <valgrind/valgrind.h> header file available.

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

EOF

my $valgrind = prompt ("Enable valgrind support (y/n)?",
                       -r "/usr/include/valgrind/valgrind.h" ?  "y" : "n");
$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 IT 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;

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

EOF

WriteMakefile(
  NAME         => "Coro::State",
  VERSION_FROM => "State.pm",
  DEFINE       => $DEFINE,
  LIBS         => @LIBS,
  DIR          => [],
);

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.56
Committed:	Fri Apr 25 04:28:50 2008 UTC (16 years, 2 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-4_74, rel-4_71, rel-4_72, rel-4_73, rel-4_7
Changes since 1.55:	+10 -8 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.7	use 5.005;
2	root	1.1
3	root	1.55	use strict;
4			use ExtUtils::MakeMaker;
5	root	1.2	use Config;
6
7	root	1.6	$\|=1;
8
9	root	1.55	my $DEFINE;
10			my @LIBS = [];
11	root	1.2
12	root	1.44	print <<EOF;
13
14			* * * * * * * * * * * * * * * * * *
15
16			Coro has a number of configuration options. Due to its maturity, the
17			defaults that Coro chooses are usually fine, so you can decide to skip
18			these questions. Only if something went wrong you should select 'n'
19			here and manually configure Coro, and, of course, report this to the
20			maintainer :)
21
22			EOF
23
24	root	1.45	if (prompt ("Skip further questions and use defaults (y/n)?", "y") =~ /[yY]/) {
25	root	1.44	$ENV{PERL_MM_USE_DEFAULT} = 1;
26			}
27
28
29	root	1.2	$DEFINE .= " -DHAVE_MMAP" if $Config{d_mmap} eq "define" && $Config{d_munmap} eq "define";
30
31	root	1.55	my $iface;
32
33	root	1.49	if (exists $ENV{CORO_INTERFACE}) {
34			$iface = $ENV{CORO_INTERFACE};
35	root	1.50
36	root	1.49	} elsif ($^O =~ /win32/i or $^O =~ /cygwin/ or $^O =~ /mswin/) {
37	root	1.34	$iface = 'w';
38	root	1.50
39	root	1.14	} elsif ($^O =~ /irix/) {
40			$iface = "i";
41	root	1.50
42	root	1.4	} elsif ($^O =~ /linux/) {
43	root	1.50	# default to assembly on x86 and x86_64, and setjmp on others
44	root	1.52	$iface = $Config{archname} =~ /^(i[3456]86\|amd64\|x86_64)-/ && $Config{optimize} =~ /-O/ ? "a" : "s";
45	root	1.48
46	root	1.24	} elsif ($^O =~ /(free\|net\|open)bsd/) {
47	root	1.40	# FreeBSD 4.x has ucontext.h but no makecontext et al. (see BUGS section of
48	root	1.24	# man context). Assume the same problem for all other BSDs.
49	root	1.50
50			# default to assembly on x86 and x86_64, and setjmp on others
51	root	1.52	$iface = $Config{archname} =~ /^(i[3456]86\|amd64\|x86_64)-/ && $Config{optimize} =~ /-O/ ? "a" : "s";
52	root	1.50
53	root	1.8	} elsif ($^O =~ /solaris/) {
54			$iface = "s";
55	root	1.50
56	root	1.25	} elsif ($^O =~ /darwin/) {
57			$iface = "s";
58	root	1.50
59	root	1.40	} elsif (-e "/usr/include/ucontext.h") { # shame on this heuristic
60	root	1.3	$iface = "u";
61	root	1.50
62	root	1.2	} else {
63	root	1.3	$iface = "s";
64	root	1.2	}
65
66	root	1.44	print <<EOF;
67	root	1.2
68	root	1.38	* * * * * * * * * * * * * * * * * *
69
70	root	1.40	Coro can use a number of methods to implement coroutines at the C
71			level. The default chosen is based on your current confguration and is
72			correct in most cases, but you still can chose between these alternatives:
73	root	1.34
74			u The unix 'ucontext.h' functions are relatively new and not implemented
75	root	1.48	or well-tested in older unices. They allow very fast coroutine creation
76			and reasonably fast switching, and, most importantly, are very stable.
77	root	1.49	It is, however, usually slower than the other alternatives due to an
78			extra syscall done by swapcontext.
79	root	1.4
80			s If the ucontext functions are not working or you don't want
81	root	1.48	to use them for other reasons you can try a workaround using
82			setjmp/longjmp/sigaltstack (also standard unix functions). Coroutine
83	root	1.49	creation is rather slow, but switching is very fast (often much faster
84			than with the ucontext functions). Unfortunately, glibc-2.1 and
85			below don't even feature a working sigaltstack. You cannot use this
86			implementation if some other code uses SIGUSR2 or you plan to
87			create coroutines from an alternative signal stack, as both are being
88			used for coroutine creation.
89
90	root	1.53	a Handcoded assembly. This is the fastest and most compatible method
91			with the least side effects, if it works, that is. It has been tested
92			on GNU/Linux x86 and x86_64 systems and should work on all x86/x86_64
93	root	1.56	systems using the SVR ELF ABI (it is also reported to be working on
94			Strawberry Perl for Windows using MinGW). This is the recommended
95			method on supported platforms. Note that you usually have to compile
96			this module with optimisation enabled for this method to work, and
97			also more esoteric switches such as -fomit-leaf-frame-pointer might be
98			required. When i doubt, use another method, such as (s)etjmp/longjmp.
99	root	1.4
100	root	1.38	l GNU/Linux. Very old GNU/Linux systems (glibc-2.1 and below) need
101	root	1.48	this hack. Since it is very linux-specific it is also quite fast and
102			recommended even for newer versions; when it works, that is (currently
103			x86 and a few others only. If it compiles, it's usually ok). Newer
104	root	1.49	glibc versions (>= 2.5) stop working with this implementation again.
105	root	1.14
106	root	1.40	i IRIX. For some reason, SGI really does not like to follow the single
107	root	1.48	unix specification (does that surprise you?), so this workaround might
108			be needed (it's fast), although [s] and [u] should also work now.
109	root	1.2
110	root	1.56	w Microsoft Windows. Try this on Microsoft Windows when using Cygwin or
111			the MSVC compilers (e.g. ActiveState Perl, but see "a" for Strawberry
112			Perl), although, as there is no standard on how to do this under
113			windows, different enviroments might work differently. Doh.
114	root	1.34
115	root	1.55	p Use pthread API. Try to avoid this option, it was only created to make
116			a point about the programming language shootout and might leak threads.
117			It might work fine as a last resort, however.
118
119	root	1.28	For most systems, the default chosen should be OK. If you experience
120	root	1.53	problems then you should experiment with this setting and/or turn
121			optimisations on or off (make OPTIMIZE=-O0).
122	root	1.28
123	root	1.2	EOF
124	root	1.3
125			retry:
126	root	1.14
127	root	1.44	my $r = prompt "Use which implementation,\n" .
128	root	1.49	"<s>et/longjump, <u>context, <a>ssembly, <i>rix, <l>inux or <w>indows?",
129	root	1.44	$iface;
130			$iface = lc $1 if $r =~ /(\S)/;
131
132			if ($iface eq "u") {
133			$DEFINE .= " -DCORO_UCONTEXT";
134			print "\nUsing ucontext implementation\n\n";
135			conftest("TEST_makecontext");
136			} elsif ($iface eq "s") {
137			$DEFINE .= " -DCORO_SJLJ";
138			print "\nUsing setjmp/longjmp/sigaltstack implementation\n\n";
139			conftest("TEST_sigaltstack");
140			} elsif ($iface eq "l") {
141			$DEFINE .= " -DCORO_LINUX";
142			print "\nUsing linux-specific implementation\n\n";
143			} elsif ($iface eq "i") {
144			$DEFINE .= " -DCORO_IRIX";
145			print "\nUsing irix-specific implementation\n\n";
146			} elsif ($iface eq "w") {
147			$DEFINE .= " -DCORO_LOSER";
148			print "\nUsing windows-specific implementation\n\n";
149	root	1.49	} elsif ($iface eq "a") {
150			$DEFINE .= " -DCORO_ASM";
151			print "\nUsing handcoded assembly implementation\n\n";
152	root	1.55	} elsif ($iface eq "p") {
153			$DEFINE .= " -DCORO_PTHREAD";
154			@LIBS = ["-lpthread"];
155			print "\nUsing pthread implementation\n\n";
156	root	1.3	} else {
157	root	1.44	print "\nUnknown implementation \"$iface\"\n";
158			goto retry;
159	root	1.3	}
160	root	1.2
161	root	1.36	print <<EOF;
162
163	root	1.38	* * * * * * * * * * * * * * * * * *
164
165			Per-context stack size factor: Depending on your settings, Coro tries to
166			share the C stack as much as possible, but sometimes it needs to allocate
167			a new one. This setting controls the maximum size that gets allocated,
168	root	1.40	and should not be set too high, as memory and address space still is
169	root	1.38	wasted even if it's not fully used. The value entered will be multiplied
170			by sizeof(long), which is usually 4 on 32-bit systems, and 8 on 64-bit
171	root	1.37	systems.
172
173	root	1.38	A setting of 16384 (the default) therefore corresponds to a 64k..128k
174	root	1.40	stack, which usually is ample space (you might even want to try 8192 or
175	root	1.38	lower if your program creates many coroutines).
176	root	1.37
177	root	1.41	On systems supporting mmap and dynamic memory management, the actual
178			memory usually gets allocated on demand, but with many large stacks you
179			can still run out of address space on your typical 32 bit platform.
180
181	root	1.40	Some perls (mostly threaded ones and perl compiled under linux 2.6) and
182			some programs (inefficient regexes can use a lot of stack space) may
183			need much, much more: If Coro segfaults with weird backtraces (e.g. in a
184			function prologue) or in t/10_bugs.t, you might want to increase this to
185			65536 or more.
186	root	1.36
187	root	1.47	The default should be fine, and can be changed at runtime with
188			Coro::State::cctx_stacksize.
189	root	1.41
190	root	1.36	EOF
191
192	root	1.45	my $stacksize = prompt ("C stack size factor?", "16384");
193	root	1.46	$DEFINE .= " -DCORO_STACKSIZE=$stacksize";
194	root	1.36
195			print "using a stacksize of $stacksize * sizeof(long)\n";
196
197	root	1.38	print <<EOF;
198
199			* * * * * * * * * * * * * * * * * *
200
201	root	1.41	Coro can optionally put a guard area before each stack segment. When the
202			stack is too small and the access is not too far outside the stack (i.e.
203			within the guard area), then the program will safely segfault instead of
204			running into other data. The cost is some additional overhead with is
205			usually negligible, and extra use of address space.
206
207			The guard area size currently needs to be specified in pages (typical
208			pagesizes are 4k and 8k). The guard area is only enabled on a few
209			hardcoded architectures and is ignored on others. The actual preprocessor
210			expression disables this feature if:
211
212			!__i386 && !__x86_64 && !__powerpc && !__m68k \
213			&& !__alpha && !__mips && !__sparc64
214
215			The default, as usual, should be just fine.
216
217			EOF
218
219	root	1.45	my $stackguard = prompt ("Number of guard pages (0 disables)?", "4");
220	root	1.46	$DEFINE .= " -DCORO_STACKGUARD=$stackguard";
221	root	1.41
222			print <<EOF;
223
224			* * * * * * * * * * * * * * * * * *
225
226	root	1.43	Coro can tell valgrind about its stacks and so reduce spurious warnings
227			where valgrind would otherwise complain about possible stack switches.
228
229			Enabling this does not incur visible runtime or memory overhead, but it
230			requires that you have the <valgrind/valgrind.h> header file available.
231
232			Valgrind support is completely optional, so the default of disabling it is
233			the safe choice.
234
235			EOF
236
237	root	1.45	my $valgrind = prompt ("Enable valgrind support (y/n)?",
238	root	1.44	-r "/usr/include/valgrind/valgrind.h" ? "y" : "n");
239	root	1.46	$DEFINE .= " -DCORO_USE_VALGRIND=1" if $valgrind =~ /[yY]/;
240	root	1.43
241	root	1.44
242			print <<EOF;
243
244			* * * * * * * * * * * * * * * * * *
245
246			Coro can use (or even trick) some perl functions into doing what it needs
247			instead of relying on (some) of its own functions. This might increase
248			chances that it compiles and works, but it could just as well result in
249			memory leaks, crashes or silent data corruption. It certainly does result
250	root	1.51	in slightly slower speed and higher memory consumption, though, so YOU
251			SHOULD ENABLE IT ONLY AS A LAST RESORT.
252	root	1.44
253			EOF
254
255	root	1.45	my $use_internals = prompt ("Prefer perl functions over coro functions (y/n)?", "n");
256	root	1.46	$DEFINE .= " -DCORO_PREFER_PERL_FUNCTIONS=1" if $use_internals =~ /[yY]/;
257	root	1.44
258	root	1.43	print <<EOF;
259
260			* * * * * * * * * * * * * * * * * *
261
262	root	1.38	EOF
263	root	1.36
264	root	1.1	WriteMakefile(
265	root	1.2	NAME => "Coro::State",
266			VERSION_FROM => "State.pm",
267			DEFINE => $DEFINE,
268	root	1.55	LIBS => @LIBS,
269	root	1.2	DIR => [],
270	root	1.1	);
271	root	1.2
272	root	1.15	sub conftest {
273			my $type = shift;
274
275			print "\nTrying to detect stack growth direction (for $type)\n";
276			print "You might see some warnings, this should not concern you.\n\n";
277			system "$Config{cc} $Config{ccflags} -D$type libcoro/conftest.c";
278
279			my $res = qx<./a.out>;
280			$res =~ s/\s+$//;
281			my ($sp, $ss) = split /,/, $res;
282
283			print "\n\n*****************************************************************************\n";
284			print "If the testsuite fails PLEASE provide the following information\n";
285	root	1.32	print "to Marc Lehmann <schmorp\@schmorp.de>: operating system name, version,\n";
286	root	1.15	print "architecture name and this string '$sp\|$ss'. Thanks a lot!\n";#d#
287			print "*****************************************************************************\n\n";
288
289			unlink "a.out";
290	root	1.17	unlink "conftestval";
291	root	1.15	}
292	root	1.2