[Pdx-pm] Designing a C library specifically for HLL binding

Eric Wilhelm enobacon at gmail.com
Thu Oct 30 15:13:08 PDT 2008

# from chromatic
# on Thursday 30 October 2008 13:30:

>> The HLL
>> binding would then be doing all of the memory allocation (part of
>> the plan being to minimize the memory footprint, but also to make a
>> 'Perlish' API.)
>This makes the HLL binding do a lot more work.

That's actually part of the plan.  Given that making a perlish API for 
any non-trivial data requires some manipulation of HV's and AV's 
(aka "a lot of work"), and that I have to write everything from a blank 
slate, I was figuring on keeping the shared library rather dumb.

>It has to know how 
> much memory to allocate (which can vary from platform to platform),

The goal there was "none".  The temporary structs are lexically scoped 
by the caller (this is called an "automatic variable"?) and pointers to 
them are passed into the shared functions, so nothing in the shared 
library deals with memory.

  // in sharedthingy.h
  struct pointstruct {
    float x;
    float y;
    float z;

  // in Inline::C code:
  SV* next_polygon(SV* obj) {
    filedatastruct* fds = (filedatastruct*) SvIV(SvRV(obj));
    HV * hash = newHV();
    int i;
    int p;
    pointstruct * a_point;
    p = get_polygon_point_count(fds);
    for(i=0; i<p; i++) {
      get_polygon_point(fds, i, a_point);
      ... hand-waving about the array of arrays for now ...
      av_push(pt, newSVnv(a_point->x);
      av_push(pt, newSVnv(a_point->y);
      av_push(pt, newSVnv(a_point->z);
    return(newRV_noinc((SV*) hash));

At least, that's what I have in my head thus far.  Am I correct in my 
reading that there's nothing to malloc/free here outside of what the 
perlapi calls are doing for me?

> so you'll end up recompiling the HLL binding every time the shared
> library changes.

Assuming that I *want* some part of this to be in XS, you have to do 
that anyway, right?

At least, I think I want the loop over e.g. get_polygon_point() to be 
happining in the XS.  Meaning, that for e.g. 1000 polygons you would 
have 4000+ function calls between the XS and C code but only 1000 calls 
to the XS function (each of these returns a hash reference such as
"{points => [[$x0,$y0],[$x1,$y1],[$x2,$y2]], color => 0xFF0000, ...}".)

The alternative seems to be writing a lot of repetitive perl code, or a 
lot of C code which deals with memory management which will have to 
then be done over again in XS to get a binding.  So, I'm thinking there 
would be no next_polygon() function in the shared library.

This would mean that the low-level stuff in the shared library could 
stick to just dealing with the bitwise twiddly stuff, while the binding 
would mostly deal with assembling Perl data structures and error 

Now of course this assumes that the interpreter is implemented in C.  
What would something like this mean in parrot?

"Everything should be made as simple as possible, but no simpler."
--Albert Einstein

More information about the Pdx-pm-list mailing list