X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fffi-chap.xml;h=2fef13515d71319a1dc3b9a7369390b8bb252827;hb=a87ffbd2eba9a4e351814d35ce1a7cfdeb2d53af;hp=b33e95abb6e67ee60164ad14d23f6f5832745eeb;hpb=83d563cb9ede0ba792836e529b1e2929db926355;p=ghc-hetmet.git
diff --git a/docs/users_guide/ffi-chap.xml b/docs/users_guide/ffi-chap.xml
index b33e95a..2fef135 100644
--- a/docs/users_guide/ffi-chap.xml
+++ b/docs/users_guide/ffi-chap.xml
@@ -6,10 +6,10 @@
Foreign function interface (FFI)
- GHC (mostly) conforms to the Haskell 98 Foreign Function Interface
- Addendum 1.0, whose definition is available from http://www.haskell.org/.
+ GHC (mostly) conforms to the Haskell Foreign Function Interface,
+ whose definition is part of the Haskell Report on http://www.haskell.org/.
- To enable FFI support in GHC, give the
+ FFI support is enabled by default, but can be enabled or disabled explicitly with the flag.GHC implements a number of GHC-specific extensions to the FFI
@@ -51,7 +51,7 @@ Foreign function interface (FFI)
calling arbitrary IO procedures in some part of the program.)
The Haskell FFI already specifies that arguments and results of
-foreign imports and exports will be automatically unwrapped if they are
+foreign imports and exports will be automatically unwrapped if they are
newtypes (Section 3.2 of the FFI addendum). GHC extends the FFI by automatically unwrapping any newtypes that
wrap the IO monad itself.
More precisely, wherever the FFI specification requires an IO type, GHC will
@@ -78,6 +78,86 @@ OK:
details see the GHC developer wiki.
+
+
+ Interruptible foreign calls
+
+ This concerns the interaction of foreign calls
+ with Control.Concurrent.throwTo.
+ Normally when the target of a throwTo is
+ involved in a foreign call, the exception is not raised
+ until the call returns, and in the meantime the caller is
+ blocked. This can result in unresponsiveness, which is
+ particularly undesirable in the case of user interrupt
+ (e.g. Control-C). The default behaviour when a Control-C
+ signal is received (SIGINT on Unix) is to raise
+ the UserInterrupt exception in the main
+ thread; if the main thread is blocked in a foreign call at
+ the time, then the program will not respond to the user
+ interrupt.
+
+
+
+ The problem is that it is not possible in general to
+ interrupt a foreign call safely. However, GHC does provide
+ a way to interrupt blocking system calls which works for
+ most system calls on both Unix and Windows. A foreign call
+ can be annotated with interruptible instead
+ of safe or unsafe:
+
+
+foreign import ccall interruptible
+ "sleep" :: CUint -> IO CUint
+
+
+ interruptible behaves exactly as
+ safe, except that when
+ a throwTo is directed at a thread in an
+ interruptible foreign call, an OS-specific mechanism will be
+ used to attempt to cause the foreign call to return:
+
+
+
+ Unix systems
+
+
+ The thread making the foreign call is sent
+ a SIGPIPE signal
+ using pthread_kill(). This is
+ usually enough to cause a blocking system call to
+ return with EINTR (GHC by default
+ installs an empty signal handler
+ for SIGPIPE, to override the
+ default behaviour which is to terminate the process
+ immediately).
+
+
+
+
+ Windows systems
+
+
+ [Vista and later only] The RTS calls the Win32
+ function CancelSynchronousIO,
+ which will cause a blocking I/O operation to return
+ with the
+ error ERROR_OPERATION_ABORTED.
+
+
+
+
+
+ If the system call is successfully interrupted, it will
+ return to Haskell whereupon the exception can be raised. Be
+ especially careful when
+ using interruptible that the caller of
+ the foreign function is prepared to deal with the
+ consequences of the call being interrupted; on Unix it is
+ good practice to check for EINTR always,
+ but on Windows it is not typically necessary to
+ handle ERROR_OPERATION_ABORTED.
+
+
@@ -94,7 +174,7 @@ OK:
When GHC compiles a module (say M.hs)
- which uses foreign export or
+ which uses foreign export or
foreign import "wrapper", it generates two
additional files, M_stub.c and
M_stub.h. GHC will automatically compile
@@ -143,7 +223,7 @@ extern HsInt foo(HsInt a0);
––make, as GHC will automatically link in the
correct bits).
-
+ Using your own <literal>main()</literal>Normally, GHC's runtime system provides a
@@ -165,18 +245,11 @@ extern HsInt foo(HsInt a0);
#include "foo_stub.h"
#endif
-#ifdef __GLASGOW_HASKELL__
-extern void __stginit_Foo ( void );
-#endif
-
int main(int argc, char *argv[])
{
int i;
hs_init(&argc, &argv);
-#ifdef __GLASGOW_HASKELL__
- hs_add_root(__stginit_Foo);
-#endif
for (i = 0; i < 5; i++) {
printf("%d\n", foo(2500));
@@ -203,26 +276,6 @@ int main(int argc, char *argv[])
(i.e. those arguments between
+RTS...-RTS).
- Next, we call
- hs_add_rooths_add_root
- , a GHC-specific interface which is required to
- initialise the Haskell modules in the program. The argument
- to hs_add_root should be the name of the
- initialization function for the "root" module in your program
- - in other words, the module which directly or indirectly
- imports all the other Haskell modules in the program. In a
- standalone Haskell program the root module is normally
- Main, but when you are using Haskell code
- from a library it may not be. If your program has multiple
- root modules, then you can call
- hs_add_root multiple times, one for each
- root. The name of the initialization function for module
- M is
- __stginit_M, and
- it may be declared as an external function symbol as in the
- code above. Note that the symbol name should be transformed
- according to the Z-encoding:
-
@@ -300,9 +353,6 @@ int main(int argc, char *argv[])
// Initialize Haskell runtime
hs_init(&argc, &argv);
- // Tell Haskell about all root modules
- hs_add_root(__stginit_Foo);
-
// do any other initialization here and
// return false if there was a problem
return HS_BOOL_TRUE;
@@ -314,14 +364,14 @@ int main(int argc, char *argv[])
The initialisation routine, mylib_init, calls
- hs_init() and hs_add_root() as
+ hs_init() as
normal to initialise the Haskell runtime, and the corresponding
deinitialisation function mylib_end() calls
hs_exit() to shut down the runtime.
-
+
Using header files
@@ -346,7 +396,7 @@ int main(int argc, char *argv[])
available when compiling an inlined version of a foreign call,
so the compiler is free to inline foreign calls in any
context.
-
+
The -#include option is now
deprecated, and the include-files field
in a Cabal package specification is ignored.
@@ -431,17 +481,17 @@ int main(int argc, char *argv[])
-
+
Multi-threading and the FFI
-
+
In order to use the FFI in a multi-threaded setting, you must
use the option
(see ).
-
+
Foreign imports and multi-threading
-
+
When you call a foreign imported
function that is annotated as safe (the
default), and the program was linked
@@ -450,7 +500,7 @@ int main(int argc, char *argv[])
program was linked without ,
then the other Haskell threads will be blocked until the
call returns.
-
+
This means that if you need to make a foreign call to
a function that takes a long time or blocks indefinitely,
then you should mark it safe and
@@ -484,13 +534,13 @@ int main(int argc, char *argv[])
is platform dependent, but is intended to cause blocking
system calls to return immediately with an interrupted error
code. The underlying operating system thread is not to be
- destroyed.
+ destroyed. See for more details.
The relationship between Haskell threads and OS
threads
-
+
Normally there is no fixed relationship between Haskell
threads and OS threads. This means that when you make a
foreign call, that call may take place in an unspecified OS
@@ -510,17 +560,16 @@ int main(int argc, char *argv[])
for the Control.Concurrent
module.
-
+
Foreign exports and multi-threading
-
+
When the program is linked
with , then you may
invoke foreign exported functions from
multiple OS threads concurrently. The runtime system must
be initialised as usual by
- calling hs_init()
- and hs_add_root, and these calls must
+ calling hs_init(), and this call must
complete before invoking any foreign
exported functions.
@@ -563,10 +612,68 @@ int main(int argc, char *argv[])
isn't necessary to ensure that the threads have exited first.
(Unofficially, if you want to use this fast and loose version of
hs_exit(), then call
- shutdownHaskellAndExit() instead).
+ shutdownHaskellAndExit() instead).
-
+
+
+ Floating point and the FFI
+
+
+ The standard C99 fenv.h header
+ provides operations for inspecting and modifying the state of
+ the floating point unit. In particular, the rounding mode
+ used by floating point operations can be changed, and the
+ exception flags can be tested.
+
+
+
+ In Haskell, floating-point operations have pure types, and the
+ evaluation order is unspecified. So strictly speaking, since
+ the fenv.h functions let you change the
+ results of, or observe the effects of floating point
+ operations, use of fenv.h renders the
+ behaviour of floating-point operations anywhere in the program
+ undefined.
+
+
+
+ Having said that, we can document exactly
+ what GHC does with respect to the floating point state, so
+ that if you really need to use fenv.h then
+ you can do so with full knowledge of the pitfalls:
+
+
+
+ GHC completely ignores the floating-point
+ environment, the runtime neither modifies nor reads it.
+
+
+
+
+ The floating-point environment is not saved over a
+ normal thread context-switch. So if you modify the
+ floating-point state in one thread, those changes may be
+ visible in other threads. Furthermore, testing the
+ exception state is not reliable, because a context
+ switch may change it. If you need to modify or test the
+ floating point state and use threads, then you must use
+ bound threads
+ (Control.Concurrent.forkOS), because
+ a bound thread has its own OS thread, and OS threads do
+ save and restore the floating-point state.
+
+
+
+
+ It is safe to modify the floating-point unit state
+ temporarily during a foreign call, because foreign calls
+ are never pre-empted by GHC.
+
+
+
+
+