[Scilab-Dev] 1 boolean = 4 bytes => 1 byte ?

[Samuel Gougeon]

Hello Clément,

Le 22/05/2018 à 11:12, Clément David a écrit :
> Hello Samuel,
>
> After some diving into the ast/types source code and debugging session I got some information :
>
>   --> disp(%t)
>      // gdb resolved the value as a <types::ArrayOf<int>> where m_iSize = 1
>      // (the size of the inner m_pRealData)
>   --> disp([%t %f %t %f])
>      // gdb resolved the value as a <types::ArrayOf<int>> where m_iSize = 4
>      // (the size of the inner m_pRealData)
>
> So in Scilab 6, there is 4 byte per boolean; to me a first thing to do before changing the current
> implementation is to let `who()` return both the memory used (including the Scilab header) and the
> memory used by the inner data storage.
>
> Note: as discussed in this ML, the overhead per for Scilab datatype (not inner value) is 208 byte
> per value, to me it is more important to reduce it first as it will impact all ArrayOf based
> datatype.

So, i understand that it is hard, or even impossible, or useless, to 
assess the
impact of a change in term of back-compatibility wrt existing datafiles.

I understand also that the Scilab devs team has finally decided -- at 
least as a first step --
to retrieve the former who() behavior to get the memory, so including 
the Scilab header.
To me, it would be anyway better to drop the "word" unit (set of 8 
bytes) and to
return the memory preferably /in bytes/. Beyond the recovery of 
[x,mem]=who(..),
this would already be an improvement.

As far as i understand it -- what's not sure --, i am not convinced by 
the last point, in terms of priority.
The main concern of the initial report is the better usage of the memory,
noticeably when doing operations on big arrays with big intermediate 
boolean arrays.
Some operations may fail because of insufficient intermediate memory.
Now, even if 1000 variables are simultaneously defined in the workspace
-- this never happens, but let's assume it is so --,
and that each one takes 208 bytes (really per value ?? i assume it is 
rather per container. Is it right?),
then this uses 208 kbytes, what's nothing.
Now, if a single boolean array is defined and used to process a whole 
1000x1000x4 RGBA image,
it uses alone 16 MB instead of 4MB, that's >>> 208 kbytes.
Avoiding to waste these 12 MB was the main aim of my initial report.

Please correct me if my calculations are wrong, with respect to this aim.

Best regards
Samuel

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.scilab.org/pipermail/dev/attachments/20180531/4614190b/attachment.htm>