On 12/21/2013 07:57 PM, Ali Çehreli wrote:
On 12/21/2013 05:44 PM, Charles Hixson wrote:
On 12/21/2013 03:52 PM, Ali Çehreli wrote:
On 12/21/2013 03:13 PM, John Colvin wrote:
> Ideally the compiler will optimise your version to be fast, but
you may
> find you get better performance by doing the bit manipulations
eplicitly:
Assuming that the program needs to support only big endian and little
endian systems (i.e. excluding systems where no D compiler exists :)),
the following is less wordy and should be equally fast:
import std.bitmanip;
import std.system;
ulong ubytesToUlong(ubyte[] block, size_t n = 0)
in
{
assert (n >= 0);
assert (n + 8 <= block.length);
}
body
{
ulong value = *cast(ulong*)(block.ptr + n);
if (std.system.endian == Endian.littleEndian) {
return *cast(ulong*)(value.nativeToBigEndian.ptr);
} else {
return value;
}
}
Ali
Will that work even when the alignment is to odd bytes? Because that's
the case I was really worried about. The ubyte array is a packed
mixture of types, some of which are isolated bytes.
No, it is not guaranteed to work unless the alignment is right.
How about this, then: :)
import std.array;
ulong ubytesToUlong(ubyte[] block, size_t n = 0)
in
{
assert (n >= 0);
assert (n + 8 <= block.length);
}
body
{
ulong value = block.front;
block.popFront();
foreach (ub; block) {
value <<= 8;
value |= ub;
}
return value;
}
Ali
Nice, but the block is longer than 8 bytes, so I should use a "for (i =
n; i < n + 8; i++)" rather than a foreach, and index off of i. I
clearly need to redo the documentation a bit (even though it's form me
of a few months from now). It needs to say something like "Convert a 8
byte slice from a ubyte array starting at index n into a ulong." n
should always be required to be specified, so I don't want a default
value. (0 was used as a test case, because I'd made a really stupid
mistake and used "^" for exponentiation, and then couldn't see what was
going on, so I was simplifying everything...and I still couldn't see
it. Actually the array starts with a ushort, which specifies the number
of ulongs to follow before a bunch of bytes that are unintelligible data
to the class that's using this function. (OTOH, it seems like something
generally useful, so I'll probably put it in a utils.d file, with some
other generally useful routines.)
OTOH, if I'm going to consider this to be a general utility function,
then I really don't want to make assumptions about where things start,
etc. Perhaps I should throw an exception (other than assertion error)
if the index is bad or the array is to short for the given index. I
need to think about that a bit more. The alternative is to use enforce
rather than assertions...though as long as I'm the only user assertions
suffice. (It's not going to be separately compiled.)
--
Charles Hixson
