Intel CPUs Reportedly Vulnerable To New "SPOILER" Speculative Attack

[pal666]

don't use intel cpu, be like me

[pal666]

Not true; Itanium outperformed x86 for pretty much it's entire lifecycle.

its entire lifecycle itanium was slower and more expensive than contemporary x86 in native code.
itanium in 2001 had 800 mhz for $4000, compare to athlon xp 1900+ 1600 mhz for $269

The reason it flopped was because there was a 20% hit to legacy x86 applications due to emulating x86 in hardware

there is no hit for native apps, it still flopped for any app. because it was slower and more expensive at the same time

[pal666]

From what I've been able to dig up, Itanium is immune to all these attack vectors due to it's pipeline being in-order. Basically, since it was designed to be massively parallel (something, ironically, we all want now) it's designers didn't need to put in all those speed-hacks that are now being exploited in x86.

intel pentiums also were in-order. because your bullshit excuse works for them too or because intel had no resources to do ooo until pentium pro? old arms were in-order, new arms are ooo. itanic was already prohibitively expensive without ooo

[CochainComplex]

its entire lifecycle itanium was slower and more expensive than contemporary x86 in native code.
itanium in 2001 had 800 mhz for $4000, compare to athlon xp 1900+ 1600 mhz for $269

you are comparing apples with pears..as far as I remember itanium was a professional not a consumer product. So it would be like comparing old opterons with fxs or xeons with ryzens.

[xcom]

And Intel is still manufacturing these wrong CPUs even today... FFS design a new good CPU, mass produce it, and give replace a shitty ones for free ( including me with 4 Intel CPUs )
So in the future visiting a web site will be similar to install a malware with admin rights?

[Weasel]

Not true; Itanium outperformed x86 for pretty much it's entire lifecycle.

Actually no it didn't, except for tasks where a GPU would be better anyway.

The simple fact is that you CANNOT do proper compile-time scheduling (this is also why CISC is superior to RISC) because it is static. Look at some piece of code for an imaginary performance-critical widget:

if(widget->isFatWidget())
{
  // do some stuff for fat widgets
}
else
{
  // do some stuff for normal widgets
}

And you repeat this all throughout some hot function. Very simple code, and since the isFatWidget depends on the widget type, it's fair to say it will always be predicted with 100% certainty during a hot loop. Right?

But that's not the problem. The problem is, which path do you schedule for when you compile this? There's no right answer, because both widgets can be used at runtime. The CPU itself must schedule the instructions at runtime based on its branch predictor that gets it 100% right in this case for a given widget.

This is why x86 is superior because it abstracts this away to RUNTIME instead of COMPILE TIME scheduling.

Itanium (and to a much lesser extent RISC) are in general both designed around "let the compiler do the expensive scheduling, so we can simplify the CPU", but it simply does not work in practice because you need to schedule it at RUNTIME based on speculations. And Intel found that out the hard way.

The simple fact is a CPU not reliant on speculative execution is trash at performance at anything other than crunching data like a GPU. But in that case, why even use a CPU, just use a GPU lol.

[torsionbar28]

It seems you're ignoring the fact US company introduced insecure, full of vulnerabilities CPU's to our homes, countries, hospitals, airports etc. It's more probable some US state-sponsored cyber terrorism unit from USA or israel will use it against us. This US/israel propaganda starts to get boring. Better check who blew up your twin towers and US Liberty and then we can talk about Iran and Russia.

Yawn, you've watched too many X-Files episodes.

[torsionbar28]

Not true; Itanium outperformed x86 for pretty much it's entire lifecycle. The reason it flopped was because there was a 20% hit to legacy x86 applications due to emulating x86 in hardware, and AMD undercutting Intel with the bandaid that is x86-64.

No, the reason it flopped was it cost a damn fortune, and intel didn't scale it up quickly enough. AMD64 quickly overtook the performance crown, and the rest was history. Not to mention the fact that Itanium's EPIC architecture offloaded optimization to the compiler, but the needed compilers didn't exist and were basically impossible to write. If AMD hadn't stepped in with AMD64, we'd all still be running 32 bit Pentiums.

[Wojcian]

Yawn, you've watched too many X-Files episodes.

No, I've just seen analysis and reports, so I have enough knowledge to say it was a false flag. When comes to USS Liberty there's something more about it. I respect every soldier who serves well his country and who doesn't harm innocent people (being a soldiers is not just about killing, but saving and helping others). By mentioning the X files I can safely say you neither have a honor nor respect to victims of these acts of war.

The Israeli attack by combined air and naval forces spanned two hours — as long as the attack on Pearl Harbor. The air attack alone lasted approximately 25 minutes: consisting of more than 30 sorties by approximately 12 separate planes using napalm, cannon, and rockets which left 821 holes in the ship. Following the air attack, three Israeli motor torpedo boats torpedoed the ship, causing a 40’x 40’ wide hole in her hull, and machine-gunning firefighters and stretcher-bearers attempting to save their ship and crew. More than 3,000 machine-gun bullet holes were later counted on the Liberty’s hull. After the attack was thought to have ended, three life rafts were lowered into the water to rescue the most seriously wounded. The Israeli torpedo boats returned and machine-gunned these life rafts at close range. This was followed by the approach of two large Israeli Army assault helicopters filled with armed commandos carrying what appeared to be explosive satchels (they departed after hovering over the ship for several minutes, making no attempt to communicate).

According to American survivors, a 5-by-8 feet American flag was hoisted early that morning and was flying all day until it was shot away by attacking aircraft. Within several minutes, it was replaced by the giant 7-by-13 feet holiday ensign, which flew for the duration of the attack.

According to surviving crewmembers, Israeli reconnaissance aircraft closely studied the Liberty over an eight-hour period prior to the attack, one flying within two hundred feet of the ship. At all times the Liberty was a clearly marked American ship in international waters, proceeding at a speed of only 5 knots.

Ps. It seem you didn't bother to acknowledge it's USA CPUs company that polluted most of the countries in the world by potential backdoors in every possible IT segment. By accusing China or Iran in this case you just show your words are trash.

[GreenReaper]

The problem of knowledge can be resolved, in part, by PGO (Profile-Guided Optimization). This essentially runs the code instrumented on test data to determine actual usage before recompiling to best-accommodate that usage. It can provide a significant benefit. Obviously, it depends on the workload you give it, which should be representative of usage. Compilation is also slower because it has to pre-build and run it through profiling.

In the Linux kernel, they throw "likely()/unlikely()" everywhere to provide a similar compiler hint without having to actually run it.