3 ms·
> the only reason there is anything special about 8 bits as a unit of data is because hardware is built to operate on units of 8 bits at a time. More precisely
by pdonis 10y ago
> the only reason there is anything special about 8 bits as a unit of data is because hardware is built to operate on units of 8 bits at a time.
More precisely, hardware at the time that "the natural unit of data" was becoming a standardized convention was built to operate on units of 8 bits at a time. As you say, the 8-bit convention is mainly for historical reasons, and hardware today can handle larger chunk sizes.
> Python exposes 8-bit florbs, but not other sizes of florbs
To the extent it exposes florbs at all, yes. But that does not mean you are stuck with 8-bit operations in Python in all cases. For example, operations on Python floats use the IEEE standard data chunks, which, as you note, are not 8-bit. Operations on Python integers are not restricted to using 8-bit CPU instructions; they will use whatever register sizes the hardware allows (more precisely, the hardware the Python interpreter was compiled for--if you run a 32-bit Python interpreter on a 64-bit machine, you won't be using 64-bit register operations). It is true that the programmer has no control over the data chunk sizes that Python uses; they are hard-coded into the interpreter.
> Common Lisp has arbitrarily sized florbs.
Can you give an example of how this capability in CL is used?
- lispm 10y ago> Can you give an example of how this capability in CL is used? Common Lisp for example can extract/set a byte given its width and its position: CL-USER 145 > (write (ldb (byte 11 2) #b1100101011010110) :base 2) 1010110101 (byte 11 2) is a specifier for this: 11 = width, 2 = position. Historically this comes form a DEC PDP-10 instruction 'load byte'.
- lisper 10y agoThe best example I can think of is implementing certain cryptographic algorithms, particularly symmetric ciphers and cryptographically secure hash functions, which are often defined in terms of 32 and 64-bit chunks and mod 2^32 and mod 2^64 arithmetic. Why not just use C? Because the C language spec has "features" that allow a C compiler optimize away parts of your code that you really don't want optimized away in crypto code. For example, if you do this: int secret_key[SIZE]; ... for (int i=0; i<SIZE; i++) secret_key[i]=0; // Clear secret key so attacker can't read it A C compiler is allowed to get rid of that code if it can prove that it doesn't contribute to the final result (the "as-if" rule). Forcing a C compiler to not do such things is generally very tricky.
- kazinator 10y agoNot really. Just put the clearing function into another translation unit. clear_memory(secret_key, sizeof secret_key); (And don't enable any wacky whole program link-time optimizations. Those violate ISO C by continuing semantic analysis into translation phase 8. ISO C makes it clear that tokens are "syntactically and semantically analyzed" in phase 7, as translation unit. Then in phase 8, only references are resolved to link. Doing any semantic analysis to optimize things at link time violates the conceptual model thereby given. GCC has support for this but it has to be explicitly enabled; moreover, there is more to using link-time optiizations than just passing options.) The current translation unit must really call clear_memory and really pass it the pointer to the secret_key, whose contents have to be settled. The writes performed by clear_memory really have to take place, because the caller depends on it; clear_memory has no idea that the object is dead (having no next use) in the calling translation unit. The main problem is not getting the clearing not to be elided, but with stray copies of the data being elsewhere. The C programmer doesn't have visibility and control over all the storage areas where a datum may end up. If secret_key is really cleared, is that enough?