Perhaps worth noting that the number of lines in a cache is often different than the number of rows, which can be relevant for some workloads.
The size of an ordinary cache is rows × ways × size(line), where rows = 2 ↑ num-idx-bits. For example, most Intel 64 and AMD 64 processors use log₂(size(page)) − log₂(size(line)) = 12 − 6 = 6 index bits for the L1 cache*, so an L1 cache with 8-way associativity is 64 sets × 8 lines/set × 64 bytes/line = 32 KB large, and an L1 cache with 12-way associativity is 64 × 12 × 64 = 48 KB large. I remember being surprised to learn that most processors have only 64 rows in the L1 cache!
*So that virtual indexes and physical indexes are identical (so that retrieval of the row can happen in parallel with TLB lookup).
There’s an analysis of the Schraudolph approximation of the exponential function (along with an improvement upon it) that someone might find interesting at https://typ.dev/attention#affine-cast
I believe Peano dot notation works the other way ’round;
A . B : C :. D
would be, as I understand it, equivalent to:
((A B) C) D
The “general principle” is that a larger number of dots indicates a larger subformula.¹
What if you need to nest parentheses? Then you use more dots. A double dot (:) is like a single dot, but stronger. For example, we write ((1 + 2) × 3) + 4 as 1 + 2 . × 3 : + 4, and the double dot isolates the entire 1 + 2 . × 3 expression into a single sub-formula to which the + 4 applies.²
A dot can be thought of as a pair of parentheses, “) (”, with implicit parentheses at the beginning and end as needed.
In general the “direction” rule for interpreting a formula ‘A.B’ will be to first indicate that the center dot “works both backwards and forwards” to give first ‘A).(B’, and then the opening and closing parentheses are added to yield ‘(A).(B)’. The extra set of pairs of parentheses is then reduced to the formula (A.B).³
So perhaps one way of thinking about it is that more dots indicates more separation.
I may be wrong, but I believe the name of the type family is simply Times New; the name of the italic face would then be Times New Italic rather than the contradictory Times New Roman Italic. It’s strange that the name of the roman face specifically is always used; I’d suppose it’s merely because that’s how the digital fonts were inadvertently named? Times New Roman has been the name in dropdown menus, and most laypeople are unfamiliar with roman as a term of art, so there’s no reason people wouldn’t use that name. But I wonder how the digital fonts came to be named Times New Roman rather than Times New.
> A data race occurs any time two threads access the same memory location concurrently and non-deterministically when at least one of the accesses is a write.
From what I understand of the C++ memory model (shared by C and Rust), this is not the definition of data race – a data race occurs when two or more threads access memory concurrently where at least one access is a write and the accesses are unsynchronized. However, synchronized accesses may not have a deterministic ordering, in which case a race condition occurs.
(Confusing as it may be, I believe this is standard terminology.)
Yes, someone will redistribute it without charge, but there are still ways you can make money from libre software:
• selling physical media (e.g. an installation disk or drive)
• selling downloads from a trusted, official server (with the bandwidth to serve a global audience)
• selling support
• asking for donations
• adopting a patreon model (if you want so-and-such feature or modification, please fund me so that I can do so)
and so on. Admittedly, it is more difficult to make money from libre software than non-libre software, but that seems to be a consequence of the law allowing non-libre software to be sold as it is (i.e. treating software like other copyrightable material). "It's more difficult to make money from libre software" is essentially "it's more difficult to make money when you don't threaten to sue people for inspecting, modifying, or exercising ownership of the tools they use". We could similarly say "it's easier to make money when you can threaten people at gunpoint", which would simply be true! were it not for society imposing a high price (imprisonment) for doing so.
"Free" here does not mean "free of charge", it means "libre" (guarantees the four essential freedoms [1]). The common quip is "free as in freedom, not as in free beer".
The size of an ordinary cache is rows × ways × size(line), where rows = 2 ↑ num-idx-bits. For example, most Intel 64 and AMD 64 processors use log₂(size(page)) − log₂(size(line)) = 12 − 6 = 6 index bits for the L1 cache*, so an L1 cache with 8-way associativity is 64 sets × 8 lines/set × 64 bytes/line = 32 KB large, and an L1 cache with 12-way associativity is 64 × 12 × 64 = 48 KB large. I remember being surprised to learn that most processors have only 64 rows in the L1 cache!
*So that virtual indexes and physical indexes are identical (so that retrieval of the row can happen in parallel with TLB lookup).