XS has two typical uses: one is writing interfaces to external libraries, that's also what FFI::Platypus does.
But then, XS is also a way to extend Perl in its own. It is another way to write modules, for instance, when performance matters or when access to the runtime internals is required to do something. I don't thing Platypus supports that.
I have zero experience using Platypus, but I doubt any library exposing a clean FFI would allow me to do the tricks I have done in XS sometimes... though, I would never say that disallowing those would be an unacceptable trade off! | [reply] |
Great, thanks for explaining!
> the tricks I have done in XS sometimes... though, I would never say that disallowing those would be an unacceptable trade off!
well you know my opinion, that lexical macros would be the best way to go!
Hope to see you in one of the next conferences again. :)
| [reply] |
Well, perhaps we could have a Platypus XS-emulator? It will not be able to modify runtime internals, unless through an API, but the rest of XS code can be run independently of current internals. Right now (with my minimal understanding, hence the hand-waving) these internals are accessed via macros and global variables. Introduce a layer to isolate the internals: macros become functions, global variables access replaced with accessor functions. Better still, a Perl interpreter behaves like an object. It is no longer the "centre of the universe" (as https://perldoc.perl.org/perlxs.html#CAVEATS says) but it is controlled by a meta-interpreter. This way, and with an API in place for controlling and accessing interpreters, a meta-interpreter can spawn as many Perls and many different Perl versions. As long as they adhere to the API. For older Perl's a wrapper will be needed to provide this API.
Also, again with my minimal understanding, perhaps it will no longer be needed to use XS for performance but, instead, write algorithm in any Platypus-supported language and use Platypus to access it from Perl.
Here is a funny idea: statically link XS code with Perl-X.Y.Z libraries and access it via Platypus from any other Perl version. Essentially one runs two different perl versions one inside the other. Though, again, one can't control the internals and do the tricks.
edit: also relevant to this thread Re^2: Modernizing the Postmodern Language?.
| [reply] |
It is not just that internals are accessed through macros and global variables, it is that the current data structures are open.
For instance, the way perl scalars are represented internally (SV) is open. You can access the structure from XS, change it, get pointers to its slots, whatever. There is no reasonable way you could provide an API emulating that on top of a substantially different guts.
Also, any proposed solution needs to be simple, reliable and portable.
Regarding, efficiency, in many cases, efficiency is just being able to access the raw data without it passing through intermediate layers. Take for instance my module Sort::Key::Radix. Besides the algorithm, one of the reasons why it is so fast is because it manipulates directly the perl data structures. There isn't a conversion from Perl to some agnostic format when any of its subs is called or when returning from it.
| [reply] |
