[Pharo-project] [Vm-dev] Re: Can OSProcess functionality be implemented using FFI instead of plugin?

[Mariano Martinez Peck]

Hi all,

Sorry for reviving an old thread but I thought it was better to continue
the discussion here because of the context.
As you may have read, the other day I released a first approeach to a
subset of OSProcess based on FFI (posix_spwan() family of functions):

https://github.com/marianopeck/OSSubprocess

 And with that in mind, I wanted to share a few things with you. The main 2
problems I found with implementing this with FFI was:

1) We have all already agree and discussed that fork+exec cannot be done in
separate FFI calls. So at the very min you need either a plugin method that
does the fork()+exec() OR wrapping a lib like posix_spwan()

2) The other main problem, is, as you all said (and mostly  Nicolas), is
the problems with the preprocessor (constants, macros, etc).

With all that said, I was able to get my stuff working. However, I am still
using some primitives of OSProcess plugin because of 2).

I read Eliot idea and what I don't like is the need of a C compiler in the
user machine. I think that's a high constrain. Then Igor suggested that WE
(developers and maintainers of a certain tool) are the ones that compiles
the little C program to extract constant values etc and then WE provide as
part of our source code, some packages with some SharedPool depending on
the platform/OS. And Igor approach looked a bit better to me.

Then Nicolas made a point that if we plan to manage all that complexity at
the image level it may become a hell too.

So.... what if we take a simpler (probably not better) approach and we
consider the "c program that exports constants and sizes" a VM Plugin?
Let's say we have a UnixPreprocessorPlugin (that would work for OSX, Linux
and other's Unix I imagine for the time being) which provides a function
(that is exported) which answers an array of arrays. For each constant, we
include the name of the constant, the value, and the sizeof().  Then from
image side, we simply do one FFI call, we get the large array and we adapt
it to a SharedPool or whatever kind of object representing that info.

I know that different users will need different constants. But let's say
the infrastructure (plugin etc) is already done. And let's say I am a user
that I want to build something with FFI and I need some constants that I
see are not defined. Then I can simply add the ones I need in the plugin,
and next VM release will have those. If Cog gets moved to Github, then this
is even easier. Everybody can do a PR with the constants he needs. And in
fact, if we have the infrastructure in place, I think that we each of us
spend half an hour, we may have almost everything we need.

For example, I can add myself all those for signals (to use kill() from
FFI), all those from fcntl (to make none blocking pipes), all those from
wait()/waitpid() family (so that I can do a waitpid() with WNOHANG), etc
etc etc.

I know it's not the best approach but it's something that could be done
very easily and would allow A LOT of stuff to be moved to FFI just because
we have no access to preprocess constants or sizeof()  (to know how to
allocate). I also know this won't cover macros and other stuff. But still.

If you think this is a good idea, I can spend the time to do it.

Cheers,









On Thu, May 10, 2012 at 10:09 AM, Nick Ager <nick.ager at gmail.com> wrote:

> <snip>
> Well, like opendbx, maybe because opengl has quite standard interface...
> </snip>
>
> and
>
> <snip>
> It's not that it's not doable, it's that we gonna reinvent gaz plant
> and it gonna be so boring...
> I'd like to see a proof of concept, even if we restrict to libc, libm,
> kernel.dll, msvcrt.dll ...
> </snip>
>
> <snip>
> Is the unix style select()
> ubiquitous or should I use WaitForMultipleObject() on Windows? Are
> specification of read/write streams implementation machine independant
> (bsd/sysv/others...)
> </snip>
>
> Perhaps *a* way forward is to try to find existing projects which have
> already created cross-platform abstractions for platform specific
> functionality. Then we can use FFI to access that interface in a similar
> way to OpenGL and OpenDBX. For example NodeJs works across unixes - perhaps
> they have a useful cross-platform abstraction, boost  has abstractions of
> IPC etc
>
> Nick
>



-- 
Mariano
http://marianopeck.wordpress.com
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.squeakfoundation.org/pipermail/vm-dev/attachments/20160116/7ebc10a6/attachment-0001.htm