1,994 karma · joined October 5, 2012
If you get Godbolt to run the program and show the output, you'll see it change with GCC version.
Obviously what is "sensible" and what is "surprising" is subjective.
Using latencies from Zen 1 instruction table (see https://www.agner.org/optimize/instruction_tables.pdf):
mov dword [rsi], eax ; MOV m,r latency is 4
add dword [rsi], 5 ; ADD m,i latency is 6
mov ebx, dword [rsi] ; MOV r,m latency is 4Each instruction depends on the result of the previous, so we need to sum all the latency figures to get the total cycle count. Is this right? How does Agner make it add up to 15?
Then for Zen 2:
mov dword [rsi], eax ; MOV m,r latency is 0 (rather than 4,
; because it is mirrored)
add dword [rsi], 5 ; ADD m,i cannot find an entry for this.
; Looks like there's a typo in the doc.
; I guess the latency is 1.
mov ebx, dword [rsi] ; MOV r,m latency is 0Again, how does Agner make it add up to 2?
And for Intel Skylake:
mov dword [rsi], eax ; MOV m,r latency is 2
add dword [rsi], 5 ; ADD m,i - latency is 5
mov ebx, dword [rsi] ; MOV r,m latency is 2> A single A100 GPU’s 54 billion transistors can execute 5 petaflops of performance, according to Nvidia.
It is a single system of 8 GPUs that can do 5 petaflops.
I can't edit my post anymore. Multiply my numbers by 8, or a bit more if you want to take into account higher utilization and the other overheads you mention. So ~500 cars. This is my final offer.
Let's say electricity generation creates 0.5 kg CO2e per kWh. So 122640 kg CO2e per year.
For comparison, driving a cars creates about 0.2kg CO2 per km. Or 0.32 kg per mile. So about the same as driving 122640 / 0.32 = 383250 miles per year. Call it 38 cars.
Edit: Corrected the above CO2 per km figure to fix a factor of 100 error.
Obviously there are a million things wrong with this analysis. For example, we don't know if they're going to use the machine to do climate modelling that will lead to a headline in the media that causes the green party to be elected ;-)
Also, if I understand correctly, it has recently been shown that people who were infected with SARS 17 years ago still have memory T cells for SARS. (And, I think SARS is one of the viruses most closely related to Covid-19, and therefore there's reason to expect a long immunity period for it too).
"Memory T cells induced by previous pathogens can shape the susceptibility to, and clinical severity of, subsequent infections. <snip> We then showed that SARS-recovered patients (n=23) still possess long-lasting memory T cells reactive to SARS-NP 17 years after the 2003 outbreak." - from https://www.nature.com/articles/s41586-020-2550-z
The other case is juvenile magpies. As adults I mostly hear them shouting aggressively at each other. But if the youngsters don't know I'm there, I've sometimes heard them chatting. The sounds they make are complex and quiet. A bit like this https://www.youtube.com/watch?v=8P4ZVgjslVQ but I've always seen them in pairs or groups when doing this.
Third is the Robin (European). They also have a whisper song. Sometimes they do it so quietly that I have to be within a few feet to hear it. And there's no other bird around. I guess it's a male who is just working on new material to impress the ladies with later.
I'm not claiming anything controversial. Power not having scaled as well as area recently is often referred to as the end of Dennard scaling:
https://en.wikipedia.org/wiki/Dennard_scaling#Breakdown_of_D...
> You can run the 64 Core on EPYC 2 all at once at 3Ghz all with Air Cooling.
That can be true despite the fact that power hasn't scaled as well as area.
> At every node they have reduced power consumption
Yep, just not as much as they improved area.
I have a simplistic explanation - maybe not what you're looking for but it is the best I can do...
At 12m23s in the video he says, "If you're working in a layer and the layers are well constructed (abstracted) you really can make a lot of progress. But if the top layer says, 'to make this really fast, go change the bottom layer', then its going to get all tangled up."
That's what implementing an algorithm on a SIMD architecture feels like to me. I have to figure out a way of filling my SIMD width with data each clock cycle, while in contrast, the specification of the algorithm deals with data one piece at a time.
Take insertion sort as a (bad) example.
i ? 1
while i < length(A)
j ? i
while j > 0 and A[j-1] > A[j]
swap A[j] and A[j-1]
j ? j - 1
end while
i ? i + 1
end while
We'd probably say the algorithm is the top level of the abstraction stack, and the SIMD architecture is a level near the bottom. So this problem is the opposite way around to how Jim phrased it, but the point is that we have NOT got clean abstraction - an implementation in one layer depends on the implementation in another.
I'm sure Intel should fix the problems Linus is complaining about, but I feel like chip vendors are being forced into this "add special purpose blocks" approach, as the only way to make their new chips better than their old ones.
I remember them being amazingly fast. I was comparing them to Amigas in 1987 though. The Motorola 68000 in the Amiga 500 was less than 1.0 dhrystone MIPS, while the Archemedes A3000 was about 4.0. For reference, the machines cost about £499 and £599 respectively in 1987.
As a result the frame rate, poly count and screen size in Zarch on the Archemedes was higher than Starglider II on the Amiga :-). Look https://youtu.be/MNXypBxNGMo?t=36, https://youtu.be/edDLqlG4quw?t=132
I think they dropped segmented stacks in 2014: https://en.wikipedia.org/wiki/Go_(programming_language)#Vers...
The stack can still grow, but contiguously. I'm not sure if there are any instructions required to monitor the stack size and grow if it needed.
From the paper: "we describe algorithmical changes to cuckoo hash tables allowing a more efficient implementation. More precisely, our hash table adds a bloom filter in each bucket that allows to prune unnecessary lookups to the secondary bucket."
> IMHO the only valid criticism is if the the simulation modelling is sound and implemented accurately.
I think the best way to tell if it is sound and implemented accurately is to first require that it is implemented as simply (to understand) as it can be. Even then, it is hard to reason about code. But without simplicity, the problem is ten times worse.
I'm tempted to go further and say that source code is formalized thought. I've written a number of simulators in the past, sometimes purely to help me understand a system more fully. There's something beautiful about describing the behaviour of a system in elegant code. When there's nothing left to remove I get much greater confidence that I've fully groked the system. I'd say this is the area where the "computers are like a bicycle for the mind" quote is the most true.
I like the way InitModel() crashes (I think) if a global pointer called bmh (short for bitmap header) isn't first initialized by calling InitBMHead() from Bitmap.cpp. I guess it's obvious to academics with giant brains that InitModel() depends on a bitmap existing.
But it gets worse - the pointer is declared in CovidSim.cpp but Bitmap.cpp reaches across the module boundary to initialize it. Sweet.
Edit: I feel bad now. It's great that this code was made public. I should be encouraging that. I think academics writing code for things like this should probably take an undergrad course on software engineering. I think the one that taught me about Abstract Data Types would be most beneficial the author(s) of this code.
As I understand it, under GDPR data controllers have a responsibility to take reasonable measures to secure the data. I believe failure to do so is a criminal offense.