Coro/Coro/Makefile.PL

use ExtUtils::MakeMaker;

use 5.005;

use Config;

$|=1;

$DEFINE = "";

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

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. 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, although, as there is
   no standard on how to do this under windows, this might work only on
   cygwin or specific versions of msvc. Your problem, your fix, our patch.

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

print <<EOF if $^O =~ /linux/;

*****************************************************************************
*                                                                           *
*  HEY!! You are using Linux! That's not at all bad, but if you get seg-    *
*  faults with Coro almost all the time please refer to README.linux-glibc  *
*                                                                           *
*****************************************************************************

EOF

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