in reply to Re^5: Storable- long integer size
in thread Storable- long integer size

Why is it effectively insisting that longsize be the same - especially given that longsize typically differs between linux and windows ?

My guess is that its because no one who appreciates the difference between LP64 & LLP64 programming models has really looked at the code since it was ported to 64-bit.

The code simply makes no attempt at differentiation. The magic_check function from Storable.xs :

/*
 * magic_check
 *
 * Make sure the stored data we're trying to retrieve has been produce
+d
 * on an ILP compatible system with the same byteorder. It croaks out 
+in
 * case an error is detected. [ILP = integer-long-pointer sizes]
 * Returns null if error is detected, &PL_sv_undef otherwise.
 *
 * Note that there's no byte ordering info emitted when network order 
+was
 * used at store time.
 */
static SV *magic_check(pTHX_ stcxt_t *cxt)
{

    ...


    current = buf + c;
    
    /* sizeof(int) */
    if ((int) *current++ != sizeof(int))
        CROAK(("Integer size is not compatible"));

    /* sizeof(long) */
    if ((int) *current++ != sizeof(long))
        CROAK(("Long integer size is not compatible"));

    /* sizeof(char *) */
    if ((int) *current != sizeof(char *))
        CROAK(("Pointer size is not compatible"));

    if (use_NV_size) {
        /* sizeof(NV) */
        if ((int) *++current != sizeof(NV))
            CROAK(("Double size is not compatible"));
    }

    return &PL_sv_undef;    /* OK */
}

[download]

(The comment could be read to suggest another, less generous, interpretation.)

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'
Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
"Science is about questioning the status quo. Questioning authority". I knew I was on the right track :)
In the absence of evidence, opinion is indistinguishable from prejudice.

Replies are listed 'Best First'.
Re^7: Storable- long integer size
by syphilis (Archbishop) on Oct 22, 2015 at 10:47 UTC
    I really didn't expect that Storable would be so fragile over a cross-platform network.

    I can now clearly see that the posts advising the OP to "do it another way" are well founded.
    (Of course, at no stage did I think those posts would prove to be otherwise ;-)

    Cheers,
    Rob
[reply]

      Whilst it wouldn't be too hard to fix this particular problem; in general it's probably not worth the effort.

      Storable, as the name suggests, is a fast, memory dump&retrieve format, not a data interchange format.

      As such, whilst it would be possible to fix-up this problem; and that could be extended to deal with mismatching byte-orders and 32/64-bit mismatches; that would inevitably make the module slower for its intended purpose.

      In the end that would be another case of feature creep ruining yet another module, by compromising its core function.

      Perhaps the module's biggest mistake is in not making clear its intended purpose and its unsuitability as an interchange format.

      With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'
      Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
      "Science is about questioning the status quo. Questioning authority". I knew I was on the right track :)
      In the absence of evidence, opinion is indistinguishable from prejudice.
[reply]
        I've got the feeling that the particular type of problem demonstrated by my example should be fixable without impacting significantly on performance.
        But perhaps I haven't grasped the importance of the longsize check, and a "feeling" isn't a very convincing argument ...

        All of your points are good ones.

        Cheers,
        Rob
[reply]

In Section Seekers of Perl Wisdom