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 ($^O =~ /win32/i or $^O =~ /cygwin/ or $^O =~ /mswin/) {
   $iface = 'w';
} elsif ($^O =~ /irix/) {
   $iface = "i";
} elsif ($^O =~ /linux/) {
   # default to setjmp/longjmp on non-x86...
   $iface = $Config{archname} =~ /^(i[3456]86|amd64|x86_64)-/ ? "l" : "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.
   $iface = "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.

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 as well (often much
faster than with the ucontext functions). Unfortunately, glibc-2.1 and
below don't even feature a working sigaltstack.

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).

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.

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

EOF

retry:

my $r = prompt "Use which implementation,\n" .
               "<s>etjmp/longjump, <u>context, <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";
} 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.

EOF

my $stacksize = prompt ("C stack size factor", "16384");
$DEFINE .= " -DSTACKSIZE=$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 .= " -DSTACKGUARD=$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 .= " -DUSE_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 .= " -DPREFER_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.44
Committed:	Tue Dec 12 13:56:45 2006 UTC (17 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.43:	+75 -44 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			if (prompt ("Skip further questions and use defaults (y/n)", "y") =~ /[yY]/) {
24			$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.34	if ($^O =~ /win32/i or $^O =~ /cygwin/ or $^O =~ /mswin/) {
31			$iface = 'w';
32	root	1.14	} elsif ($^O =~ /irix/) {
33			$iface = "i";
34	root	1.4	} elsif ($^O =~ /linux/) {
35	root	1.23	# default to setjmp/longjmp on non-x86...
36	root	1.33	$iface = $Config{archname} =~ /^(i[3456]86\|amd64\|x86_64)-/ ? "l" : "s";
37	root	1.24	} elsif ($^O =~ /(free\|net\|open)bsd/) {
38	root	1.40	# FreeBSD 4.x has ucontext.h but no makecontext et al. (see BUGS section of
39	root	1.24	# man context). Assume the same problem for all other BSDs.
40			$iface = "s";
41	root	1.8	} elsif ($^O =~ /solaris/) {
42			$iface = "s";
43	root	1.25	} elsif ($^O =~ /darwin/) {
44			$iface = "s";
45	root	1.40	} elsif (-e "/usr/include/ucontext.h") { # shame on this heuristic
46	root	1.3	$iface = "u";
47	root	1.2	} else {
48	root	1.3	$iface = "s";
49	root	1.2	}
50
51	root	1.44	print <<EOF;
52	root	1.2
53	root	1.38	* * * * * * * * * * * * * * * * * *
54
55	root	1.40	Coro can use a number of methods to implement coroutines at the C
56			level. The default chosen is based on your current confguration and is
57			correct in most cases, but you still can chose between these alternatives:
58	root	1.34
59			u The unix 'ucontext.h' functions are relatively new and not implemented
60	root	1.44	or well-tested in older unices. They allow very fast coroutine creation
61			and reasonably fast switching, and, most importantly, are very stable.
62	root	1.4
63			s If the ucontext functions are not working or you don't want
64	root	1.44	to use them for other reasons you can try a workaround using
65			setjmp/longjmp/sigaltstack (also standard unix functions). Coroutine
66			creation is rather slow, but switching is very fast as well (often much
67			faster than with the ucontext functions). Unfortunately, glibc-2.1 and
68			below don't even feature a working sigaltstack.
69	root	1.4
70	root	1.38	l GNU/Linux. Very old GNU/Linux systems (glibc-2.1 and below) need
71	root	1.44	this hack. Since it is very linux-specific it is also quite fast and
72			recommended even for newer versions; when it works, that is (currently
73			x86 and a few others only. If it compiles, it's usually ok).
74	root	1.14
75	root	1.40	i IRIX. For some reason, SGI really does not like to follow the single
76	root	1.44	unix specification (does that surprise you?), so this workaround might
77			be needed (it's fast), although [s] and [u] should also work now.
78	root	1.2
79	root	1.34	w Microsoft Windows. Try this on Microsoft Windows, although, as there is
80	root	1.44	no standard on how to do this under windows, this might work only on
81			cygwin or specific versions of msvc. Your problem.
82	root	1.34
83	root	1.28	For most systems, the default chosen should be OK. If you experience
84			problems then you should experiment with this setting and/or turn off
85			optimizations (make OPTIMIZE=-O0).
86
87	root	1.2	EOF
88	root	1.3
89			retry:
90	root	1.14
91	root	1.44	my $r = prompt "Use which implementation,\n" .
92			"<s>etjmp/longjump, <u>context, <i>rix, <l>inux or <w>indows?",
93			$iface;
94			$iface = lc $1 if $r =~ /(\S)/;
95
96			if ($iface eq "u") {
97			$DEFINE .= " -DCORO_UCONTEXT";
98			print "\nUsing ucontext implementation\n\n";
99			conftest("TEST_makecontext");
100			} elsif ($iface eq "s") {
101			$DEFINE .= " -DCORO_SJLJ";
102			print "\nUsing setjmp/longjmp/sigaltstack implementation\n\n";
103			conftest("TEST_sigaltstack");
104			} elsif ($iface eq "l") {
105			$DEFINE .= " -DCORO_LINUX";
106			print "\nUsing linux-specific implementation\n\n";
107			} elsif ($iface eq "i") {
108			$DEFINE .= " -DCORO_IRIX";
109			print "\nUsing irix-specific implementation\n\n";
110			} elsif ($iface eq "w") {
111			$DEFINE .= " -DCORO_LOSER";
112			print "\nUsing windows-specific implementation\n\n";
113	root	1.3	} else {
114	root	1.44	print "\nUnknown implementation \"$iface\"\n";
115			goto retry;
116	root	1.3	}
117	root	1.2
118	root	1.36	print <<EOF;
119
120	root	1.38	* * * * * * * * * * * * * * * * * *
121
122			Per-context stack size factor: Depending on your settings, Coro tries to
123			share the C stack as much as possible, but sometimes it needs to allocate
124			a new one. This setting controls the maximum size that gets allocated,
125	root	1.40	and should not be set too high, as memory and address space still is
126	root	1.38	wasted even if it's not fully used. The value entered will be multiplied
127			by sizeof(long), which is usually 4 on 32-bit systems, and 8 on 64-bit
128	root	1.37	systems.
129
130	root	1.38	A setting of 16384 (the default) therefore corresponds to a 64k..128k
131	root	1.40	stack, which usually is ample space (you might even want to try 8192 or
132	root	1.38	lower if your program creates many coroutines).
133	root	1.37
134	root	1.41	On systems supporting mmap and dynamic memory management, the actual
135			memory usually gets allocated on demand, but with many large stacks you
136			can still run out of address space on your typical 32 bit platform.
137
138	root	1.40	Some perls (mostly threaded ones and perl compiled under linux 2.6) and
139			some programs (inefficient regexes can use a lot of stack space) may
140			need much, much more: If Coro segfaults with weird backtraces (e.g. in a
141			function prologue) or in t/10_bugs.t, you might want to increase this to
142			65536 or more.
143	root	1.36
144	root	1.41	The default should be fine.
145
146	root	1.36	EOF
147
148	root	1.38	my $stacksize = prompt ("C stack size factor", "16384");
149	root	1.36	$DEFINE .= " -DSTACKSIZE=$stacksize";
150
151			print "using a stacksize of $stacksize * sizeof(long)\n";
152
153	root	1.38	print <<EOF;
154
155			* * * * * * * * * * * * * * * * * *
156
157	root	1.41	Coro can optionally put a guard area before each stack segment. When the
158			stack is too small and the access is not too far outside the stack (i.e.
159			within the guard area), then the program will safely segfault instead of
160			running into other data. The cost is some additional overhead with is
161			usually negligible, and extra use of address space.
162
163			The guard area size currently needs to be specified in pages (typical
164			pagesizes are 4k and 8k). The guard area is only enabled on a few
165			hardcoded architectures and is ignored on others. The actual preprocessor
166			expression disables this feature if:
167
168			!__i386 && !__x86_64 && !__powerpc && !__m68k \
169			&& !__alpha && !__mips && !__sparc64
170
171			The default, as usual, should be just fine.
172
173			EOF
174
175			my $stackguard = prompt ("Number of guard pages (0 disables)", "4");
176			$DEFINE .= " -DSTACKGUARD=$stackguard";
177
178			print <<EOF;
179
180			* * * * * * * * * * * * * * * * * *
181
182	root	1.43	Coro can tell valgrind about its stacks and so reduce spurious warnings
183			where valgrind would otherwise complain about possible stack switches.
184
185			Enabling this does not incur visible runtime or memory overhead, but it
186			requires that you have the <valgrind/valgrind.h> header file available.
187
188			Valgrind support is completely optional, so the default of disabling it is
189			the safe choice.
190
191			EOF
192
193	root	1.44	my $valgrind = prompt ("Enable valgrind support (y/n)",
194			-r "/usr/include/valgrind/valgrind.h" ? "y" : "n");
195	root	1.43	$DEFINE .= " -DUSE_VALGRIND=1" if $valgrind =~ /[yY]/;
196
197	root	1.44
198			print <<EOF;
199
200			* * * * * * * * * * * * * * * * * *
201
202			Coro can use (or even trick) some perl functions into doing what it needs
203			instead of relying on (some) of its own functions. This might increase
204			chances that it compiles and works, but it could just as well result in
205			memory leaks, crashes or silent data corruption. It certainly does result
206			in slightly slower speed and higher memory consumption, though, so you
207			should enable it only as a last resort.
208
209			EOF
210
211			my $use_internals = prompt ("Prefer perl functions over coro functions (y/n)", "n");
212			$DEFINE .= " -DPREFER_PERL_FUNCTIONS=1" if $use_internals =~ /[yY]/;
213
214	root	1.43	print <<EOF;
215
216			* * * * * * * * * * * * * * * * * *
217
218	root	1.38	EOF
219	root	1.36
220	root	1.1	WriteMakefile(
221	root	1.2	NAME => "Coro::State",
222			VERSION_FROM => "State.pm",
223			DEFINE => $DEFINE,
224			DIR => [],
225	root	1.1	);
226	root	1.2
227	root	1.15	sub conftest {
228			my $type = shift;
229
230			print "\nTrying to detect stack growth direction (for $type)\n";
231			print "You might see some warnings, this should not concern you.\n\n";
232			system "$Config{cc} $Config{ccflags} -D$type libcoro/conftest.c";
233
234			my $res = qx<./a.out>;
235			$res =~ s/\s+$//;
236			my ($sp, $ss) = split /,/, $res;
237
238			print "\n\n*****************************************************************************\n";
239			print "If the testsuite fails PLEASE provide the following information\n";
240	root	1.32	print "to Marc Lehmann <schmorp\@schmorp.de>: operating system name, version,\n";
241	root	1.15	print "architecture name and this string '$sp\|$ss'. Thanks a lot!\n";#d#
242			print "*****************************************************************************\n\n";
243
244			unlink "a.out";
245	root	1.17	unlink "conftestval";
246	root	1.15	}
247	root	1.2
248	root	1.26	print <<EOF if $^O =~ /linux/;
249
250			*****************************************************************************
251			* *
252			* HEY!! You are using Linux! That's not at all bad, but if you get seg- *
253			* faults with Coro almost all the time please refer to README.linux-glibc *
254			* *
255			*****************************************************************************
256
257			EOF
258	root	1.1