Gambit-list Août 2005

gambit-list@iro.umontreal.ca

12 participants
35 discussions

Edge triggered I/O with libevent
by Adam Langley 04 Avr '13

04 Avr '13

Gambit uses the select call on POSIX systems to multiplex IO operations. This is fine for small numbers of file descriptors, but falls apart quickly with large numbers[1]. libevent[2] is a wrapper library around a number of modern IO multiplexing systems (epoll on Linux, kqueue on the BSDs as well as poll and select). Attached is a patch which converts Gambit to using edge triggered I/O with epoll and libevent. This also requires a patch (attached) of libevent since the standard distribution doesn't include edge triggering support and the upstream appears to be on holiday. (epoll is required because I don't have a BSD box on which to develop edge triggering support for kqueue) This patch (for Gambit) preprocesses away to nothing unless --enable-libevent is passed to the configure script. (Note that, since this patches the configure.ac script, you'll need to run autoconf to regenerate). I hope I've not broken anything, but at this stage I've only tested that the console and tcp ports work. This patch (in the future) should also allow people, who write programs which use socket calls directly, to integrate into the main event loop at some point. Testing is more than welcome and, if you find a form of IO which is broken, please email me. [1] http://monkey.org/~provos/libevent/libevent-benchmark2.jpg [2] http://monkey.org/~provos/libevent/ -- Adam Langley agl(a)imperialviolet.org http://www.imperialviolet.org (+44) (0)7906 332512 PGP: 9113 256A CC0F 71A6 4C84 5087 CDA5 52DF 2CB6 3D60

2 2

handling of macros
by Christian 13 Nov '05

13 Nov '05

Hello Some questions: (the first two of those may be rather general scheme philosophy questions) - why are DSSSL style argument declarations not allowed in define-macro? - why is there no (define-macro foo (lambda(...)...)) form? Is there a lowlevel variant for setting runtime and compiletime macro bindings to some lambda? - is there a way to get at the converter lambda from a (runtime-)macro definition? - I need a way to unset a macro definition, so that the corresponding name can be used as normal function/variable binding from there on. - I'd like to be able to scan a namespace for all bindings and macro bindings. For example for readline completion. (And to be able to remove all runtime macros.) - how can I macro-expand code with the original context? Until now I've used (caddr (##decompile (eval `(lambda() ,code)))) but code is eval'ed in a new lexical context of course. (I haven't understood how to use ##macro-expand. I would be grateful for any help for understanding the sources. How do the cte (=compile-time environment?) and such work? What's the exact concept?) I want macro expansion for writing macros which expand their arguments before working on them. For playing with optimizations (kind of like optimizing mini-compilers). - is there a way to preserve the line/column numbering of source code which is "wrapped" by macros? For something like for example (receive (a b) (code1) code2) it would be nice if when an error happens in code1 or code2, the error message didn't just mention the line/column of the opening paren of the receive form, but the line/column where the relevant part of code1 or code2 is in the original file. Thanks, Christian.

3 4

Re: file-seek in Gambit.
by Marc Feeley 18 Sep '05

18 Sep '05

> I can't seem to find a way to seek in and get the position in files > using Gambit (4beta11). Wouldn't this be a handy feature? Yes, I have been planing this for a while and have just completed the implementation and documentation. Here it is: @deffn procedure input-port-byte-position @var{port} @r{[}@var{position} @r{[}@var{whence}@r{]}@r{]} @deffnx procedure output-port-byte-position @var{port} @r{[}@var{position} @r{[}@var{whence}@r{]}@r{]} When called with a single argument these procedures return the byte position where the next I/O operation would take place in the file attached to the given @var{port} (relative to the beginning of the file). When called with two or three arguments, the byte position for subsequent I/O operations on the given @var{port} is changed to @var{position}, which must be an exact integer. When @var{whence} is omitted or is 0, the @var{position} is relative to the beginning of the file. When @var{whence} is 1, the @var{position} is relative to the current byte position of the file. When @var{whence} is 2, the @var{position} is relative to the end of the file. The return value is the new byte position. On most operating systems the byte position for reading and writing of a given bidirectional port are the same. When @code{input-port-byte-position} is called to change the byte position of an input-port, all input buffers will be flushed so that the next byte read will be the one at the given position. When @code{output-port-byte-position} is called to change the byte position of an output-port, there is an implicit call to @code{force-output} before the position is changed. For example: @smallexample > @b{(define p @r{@i{; p is an input-output-port}} (open-file '(path: "test" char-encoding: latin1 create: maybe)))} > @b{(list (input-port-byte-position p) (output-port-byte-position p))} (0 0) > @b{(display "abcdefghij\n" p)} > @b{(list (input-port-byte-position p) (output-port-byte-position p))} (0 0) > @b{(force-output p)} > @b{(list (input-port-byte-position p) (output-port-byte-position p))} (11 11) > @b{(input-port-byte-position p 2)} 2 > @b{(list (input-port-byte-position p) (output-port-byte-position p))} (2 2) > @b{(peek-char p)} #\c > @b{(list (input-port-byte-position p) (output-port-byte-position p))} (11 11) > @b{(output-port-byte-position p -7 2)} 4 > @b{(list (input-port-byte-position p) (output-port-byte-position p))} (4 4) > @b{(write-char #\! p)} > @b{(list (input-port-byte-position p) (output-port-byte-position p))} (4 4) > @b{(force-output p)} > @b{(list (input-port-byte-position p) (output-port-byte-position p))} (5 5) > @b{(input-port-byte-position p 1)} 1 > @b{(read p)} bcd!fghij @end smallexample @end deffn > Also, while I'm making suggestions: Have you thought about > implementing a simple package system, for example something like > Chicken Scheme's eggs[3]? No. I'm not saying this wouldn't be useful, just that I haven't perceived a need for it yet. There's really nothing to change in Gambit itself to implement a package system like the one Chicken uses because Gambit's installation directory (/usr/local/Gambit-C) can be used for this. The subdirectory /usr/local/Gambit-C/package would store the installed packages, and the programs would use these packages like this: (include "~~/package/Xlib.scm") (include "~~/package/arrays.scm") ... or (load "~~/package/foo") The system extension file (~~/gambcext) could also be modified for the packages that need to permanently extend Gambit (this file is loaded whenever the interpreter is started). The most tedious in all of this is to implement the package management tool that installs the packages, compiles them if needed, checks for the latest version, checks package dependencies, etc. If you want to contribute such a tool please be my guest. What I can do is help you out in the design and host the packages that people contribute on Gambit's web site. Of course some of this work may have to be duplicated when the R6RS module system comes out... Marc

2 2

changing the ld options on dynamically loaded files
by Bradley Lucier 29 Aoû '05

29 Aoû '05

Marc: I have the following code that used to work in an older beta of gambit: > (define-macro (setup-loader) > (set! ##ld-cmd "/usr/ccs/bin/ld -G %s.o libfftw.so.2.0.5 -o %s") > '(begin)) > > (setup-loader) > > (c-declare > " > #include \"fftw.h\" > > fftwnd_plan p; > > ") > > (define fftw2d_create_plan_backward > (c-lambda () > void > "p = fftw2d_create_plan(64, > 64, > FFTW_BACKWARD, > FFTW_ESTIMATE | FFTW_IN_PLACE); > ")) > > (define fftw2d_create_plan_forward > (c-lambda () > void > "p = fftw2d_create_plan(64, > 64, > FFTW_FORWARD, > FFTW_ESTIMATE | FFTW_IN_PLACE); > ")) > > ;;; Both forward and backward ffts, depends on which way the plan > was created. > > (define fftwc > (c-lambda (scheme-object) > void > " > int j; double *fp = (double *)((___WORD)___BODY_AS > (___arg1,___tSUBTYPED)); > fftwnd_one(p, > (fftw_complex *)(fp), > NULL); > for (j = 0; j < 64 * 64 * 2; j++) > fp[j] *= .015625; > ")) Now I get Gambit Version 4.0 beta 13 > (compile-file "all.scm") *** ERROR IN #<procedure #2> -- Unbound variable: ##ld-cmd and there's no ##ld-cmd in gambc40b14, either. How can I set things up to link all dynamically loaded files against libfftw.so.2.0.5? Brad

2 3

New chjmodule release, Perl interface
by Christian 28 Aoû '05

28 Aoû '05

Hello I've put up a new version of the chjmodule bundle, which now includes an alpha release of my gambit->perl interface. http://scheme.mine.nu/gambit/chjmodule/ Enjoy, and tell me if something doesn't work. Christian.

1 0

open-tcp-client problem?
by Francois Magnan 26 Aoû '05

26 Aoû '05

Hi, I have some difficulties using the open-tcp-client primitive on MacOSX 10.4 with Gambit-Cb14. The primitive returns a port before that port is actually ready to be used for sending/receiving data. See below for an example (Use two separate hosts to reproduce the error... don't try this with the client and server running on the same host). If the client (host B) is MacOSX 10.4 the second call to (do-call) fails. Any hints? Thank you, Francois Magnan ------------------- ;;; ;;;; -- ;;;; simple server ;;; ; Run this on host A (define (server-start) (let ((command-queue (open-tcp-server (list port-number: 5000 reuse-address: #t eol-encoding: 'cr)))) (let loop () (let ((incoming-connection (read command-queue))) (display "Got connection\n") (serve-command incoming-connection)) (loop)))) (define (serve-command incoming-connection) (let* ((parsed-command (read incoming-connection))) (display (list "received command" parsed-command)) (if parsed-command (write "toto" incoming-connection)) (close-port incoming-connection))) (thread-start! (make-thread (lambda () (server-start)))) ------------------- ;;; ;;;; -- ;;;; simple client ;;; ; run this on host B (define Host-A-IP "206.167.88.52") (define (do-call sleep?) (let* ((connection (open-tcp-client (list server-address: Host-A- IP ; put Host A IP here port-number: 5000 eol-encoding: 'cr)))) (if sleep? (thread-sleep! 1)) (write (list 1 2 3) connection) (display "\n" connection) (force-output connection) (let ((result (read connection))) (close-port connection) result))) (define (test) (thread-sleep! 1) (display "try with sleeping...\n") (do-call #t) (display "sleeping...\n") (force-output) (thread-sleep! 1) (display "now try without sleeping...\n") (do-call #f)) ;(##repl) (test) ; Fails on MacOSX 10.4 ; Works on Windows XP (MinGW) -------------------

3 3

clos-like system available?
by Kevin Smith 26 Aoû '05

26 Aoû '05

Googling has revealed naught, so I ask the enlightened inhabitants of this list: do any clos or clos-like implementations exist which work on Gambit 4? I'm playing with Meroon right now but it has a few issues just getting it to load into gsi. All the info I can find indicates that Meroon was ported to Gambit 3, but I was hoping it might work since it is the only lib I've been able to find. Thanks, Kevin

2 1

Specialize equal?, eqv?, and = to eq? when one of the arguments is a fixnum constant.
by Bradley Lucier 22 Aoû '05

22 Aoû '05

Marc: You should specialize equal?, eqv?, and = to eq? when one of the arguments is a fixnum constant. Brad

2 1

C++ defines in GUIDE
by Adam Langley 22 Aoû '05

22 Aoû '05

>From 4b14, lib/guide/guide.h: #define min(x,y) (((x)<(y))?(x):(y)) #define max(x,y) (((x)>(y))?(x):(y)) It's illegal to define max and min in this way in C++. Modern gcc's fail to compile this. With C++ std::min and std::max can be used. AGL -- Adam Langley agl(a)imperialviolet.org http://www.imperialviolet.org (+44) (0)7906 332512 PGP: 9113 256A CC0F 71A6 4C84 5087 CDA5 52DF 2CB6 3D60

1 0

(declare (block)) and keyword arguments
by Bradley Lucier 19 Aoû '05

19 Aoû '05

Marc: I like keyword arguments, and would like to use them more, but they are relatively slow for small functions. So I have a question. Shouldn't it be possible with (declare (block)) to process keyword arguments at compile time rather than by calling ___GET_KEY at run time? Consider the following example: > (declare (block)) > > (define (foo #!key bar) > bar) > > (set! a (foo)) > > (set! b (foo bar: 2)) This expands to: > [lindv2:~] lucier% gsc -c -expansion test.scm > Expansion: > > (define foo (lambda (#!key (bar '#f)) bar)) > > (set! a ((lambda (#!key (bar '#f)) bar))) > > (set! b ((lambda (#!key (bar '#f)) bar) bar: 2)) and compiles to: > #undef ___PH_PROC > #define ___PH_PROC ___H__20_test > #undef ___PH_LBL0 > #define ___PH_LBL0 1 > #undef ___PD_ALL > #define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 > #undef ___PR_ALL > #define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 > #undef ___PW_ALL > #define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 > ___BEGIN_P_COD > ___BEGIN_P_HLBL > ___DEF_P_HLBL_INTRO > ___DEF_P_HLBL(___L0__20_test) > ___DEF_P_HLBL(___L1__20_test) > ___DEF_P_HLBL(___L2__20_test) > ___DEF_P_HLBL(___L3__20_test) > ___DEF_P_HLBL(___L4__20_test) > ___DEF_P_HLBL(___L5__20_test) > ___END_P_HLBL > ___BEGIN_P_SW > ___DEF_SLBL(0,___L0__20_test) > ___IF_NARGS_EQ(0,___NOTHING) > ___WRONG_NARGS(0,0,0,0) > ___DEF_GLBL(___L__20_test) > ___SET_STK(1,___R0) > ___SET_R0(___LBL(2)) > ___ADJFP(4) > ___POLL(1) > ___DEF_SLBL(1,___L1__20_test) > ___SET_NARGS(0) ___GOTO(___L3__20_test) > ___DEF_SLBL(2,___L2__20_test) > ___SET_GLO(1,___G_a,___R1) > ___SET_R2(___FIX(2L)) > ___SET_R1(___KEY(0,___K_bar)) > ___SET_R0(___LBL(4)) > ___SET_NARGS(2) ___GOTO(___L3__20_test) > ___DEF_SLBL(3,___L3__20_test) > ___IF_NARGS_EQ(0,___SET_R1(___FAL)) > ___GET_KEY(3,0,0,1,___SUB(0)) > ___JUMPPRM(___NOTHING,___R0) > ___DEF_SLBL(4,___L4__20_test) > ___SET_GLO(2,___G_b,___R1) > ___SET_R1(___VOID) > ___POLL(5) > ___DEF_SLBL(5,___L5__20_test) > ___ADJFP(-4) > ___JUMPPRM(___NOTHING,___STK(1)) > ___END_P_SW > ___END_P_COD Couldn't it just be > Expansion: > > (define foo (lambda (#!key (bar '#f)) bar)) > > (set! a #f) > > (set! b 2) Brad

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Gambit-list Août 2005