Posted by Lammy 19 hours ago
Having the free hardware mostly worked, but there was a long time before all of the data alignment bugs got sorted out. It got to the point where my CS classes had progressed enough that I started looking for them myself. Literally the first development tasks I got paid to do was code reviewing for word alignment bugs on 64 bit code. It was a long goddamned time ago so it's pretty fuzzy but IIRC not all 3 processors had exactly the same restrictions for all data types. So if it worked on Alpha it usually worked on the other 2 but not 100%.
I didn't have to deal with 64 bit software at work again for another 10 years, at which point people looked at me like I was trying to be edgy when I just shrugged. No, really, I was looking at 64 bit code errors 10 years ago.
The software I was writing at the time (EDA) took almost exactly twice as much memory. So if we needed more than 4GB, we could go to a 64-bit machine, but unless you bought even more than 8GB, you couldn't really run on bigger problems.
As you note, all those problems had to be sorted out 10 years later, when AMD finally forced Intel's hand into selling 64-bit computers.
A question on terminology, I come from bsd world so prefer i386, amd64, ia64(the itanium) whereas the linux side appears to prefer x86 x86-64 Nothing wrong with it(it describes the architecture fine) but I assume that x86-64 is intel face saving propaganda.
There exist two different (and slightly incompatible) implementations of 64-bit x86, which the respective CPU vendors call AMD64 and Intel 64 (previous names of the latter: EM64T and IA-32e).
So, what Intel implements is not AMD64, but something slightly different.
Concerning the small incompatibilities between AMD64 and Intel 64, see for example
> https://stackoverflow.com/questions/29833938/what-is-the-com...
I also recall the syslog being absolutely FLOODED with "unaligned access at..." messages.
It was fast. It was very fast. If you knew how to make the compiler to the precompile, test run, introspect, recompile cycle, it would work out from some sample state the right choices (branch prediction ordering?) and make your fast code even faster.
It came with NT, so there was some friction to just adding it to our services. These days were very frustrating - Microsoft was hell-bent on killing Unix, and later Linux also - and there was a lot of back and forth in our engineering team whether we wanted to invest in this hassle.
We didn't. I had that machine under my desk doing basically nothing for a year, before I sent it back.
If there had been a bit more insight into the nature of things, and if it had been running a Unix variant, we would have given it a better chance.
So then it was even more frustrating when SGI did a deal with the devil in later years, and tried to get its customers switch to NT, also. That killed SGI, in my opinion.
Looking back now, it's kind of incredible the resistance to Unix in those days, and how it was all going to be replaced with some "New Technology". Linux won. SGI didn't. And DEC was an early victim they should have learned from, in my opinion.
In 1991 the market for high-end desktop software like engineering, video editing and 3D modeling tools was dominated by Unix and classic Mac. In 1999 all of those applications were on Windows NT.
Vendors like Autodesk and Avid were building for Windows first. New graphics acceleration hardware targeted PC add-on cards rather than being exclusive to a workstation vendor (SGI tried this approach with their NT box and it flopped).
In retrospect it was just commercial Unix that had lost the game, but it wasn’t obvious at the time that Linux could reclaim this market. And Mac OS X was considered by many a doomed project (after all Apple had been promising a new OS for the entire ‘90s, nobody knew how deeply the NeXT acquisition would transform the company).
Between 1997 and 2007, I worked at 3 different companies, in 3 different countries (2 in Europe + Israel) as Design Engineer in electronics.
All the serious engineering programs for EDA/CAD were run on Solaris and accessed from Windows with X-terminal programs.
Towards the end of that decade, the Opteron-based servers were both much faster and much cheaper than the Sun servers or the Fujitsu servers, so the EDA/CAD programs were migrated from Solaris to Linux, while the Windows computers continued to run only the X-terminal programs for accessing the servers.
At the beginning of that decade, I also used a Sun workstation, but those disappeared after 1999, because they were much too slow in comparison with a PC with Intel Pentium III or with AMD Athlon.
It is likely that the reason why those EDA/CAD programs did not have Windows versions at that time was that they already required a lot of memory, typically much more than 4 GB, so they migrated from Solaris to Linux only after the availability of x86-64 servers, while having a Windows version was not possible before mid 2006, when Intel joined AMD in providing 64-bit CPUs even for PCs, not only for servers, so the market share of 64-bit PCs became non-negligible.
I know only a handful of hardware designers who use Linux/MacOS, and if they do, for sure there's a Windows VM or a spare machine in the cubical too.
Some sort of stasis has been accomplished.
For example, in 1996/1997, Digital Domain (VFX industry) used a 'render farm' cluster of Carrera Alpha workstations running NT to render the Titanic film, instead of SGIs running IRIX. (SGIs were still often used on the artists workstations though, but progressively that shifted).
By 2001, many of those machines were x86 which were then often as fast as the SGIs and Alphas, even with x86's stack-based floating point architecture which handicapped it a bit, and the significantly higher memory bandwidth and larger caches of the SGIs.
The previous Intel CPUs of the P6 family, from Pentium Pro to Pentium III, required 2 clock cycles for that, i.e. they reached at most half the throughput of Athlon at the same clock frequency. And Athlon had an even higher clock frequency.
So the launch of Athlon was one of the greatest jumps in floating-point performance per socket in the history of x86 CPUs.
It had a higher clock frequency than any Alpha. IBM POWER CPUs could do much more per clock cycle than Athlon, but their clock frequency was much lower, so Athlon was still faster.
One year and a half later Intel launched Pentium 4, which could match the throughput per clock cycle of Athlon, but only when executing new SSE2 programs, not when executing any legacy program.
> We rapidly concluded the DEC Alpha-based systems served our batch-processing needs very well. They provide extremely high floating-point performance in commodity packaging. We were able to identify certain floating-point-intensive applications as port targets. The Alpha systems could be configured with large amounts of memory and fast networking at extremely attractive price points. Overall, the DEC Alpha had the best price/performance match for our needs. [...]
> At this point, the decision was made to purchase 160 433MHz DEC Alpha systems from Carrera Computers of Newport Beach, California. Of those 160 machines, 105 of the machines are running Linux, the other 55 are running NT. The machines are connected with 100Mbps Ethernet to each other and to the rest of our facility. [...]
> The floating-point power of the DEC Alpha made jobs run about 3.5 times faster than on our old SGI systems.
An April 1992 University Video Communications presentation on the Alpha architecture https://youtube.com/watch?v=klg1FtHADso and then from 38m 19s on the 21064 CPU https://youtube.com/watch?v=klg1FtHADso&t=2299s . From about 2m52s https://youtube.com/watch?v=klg1FtHADso&t=172s to 4m 43s Richard L. Sites gives the Alpha team’s predictions from 1992 for the next 12-25 of CPU development, which seem to have been fairly on the nail.
(Sites hasn’t been idle recently either! He’s responsible for the ultra-low-overhead KUTrace: https://news.ycombinator.com/item?id=40972099 )
(Yeah, I know, several stars would've had to align for it to actually work).
What might have been.
[1] Yes, yes...PPro sucks on 16-bit software. My personal experience was that was a red herring by the benchmark-jockies, because it wasn't that much slower, and virtually none of the many, many PPro machines I was responsible for ran DOS/Win3 software.
Part of the settlement was that Intel had to fab for Digital for a long time and pay for a bunch of their patents. The Digital folks made it sound like it was a victory for them but it felt like the beginning of the end, and sure enough it was.
I think Alpha's big problem was people were still migrating to 32 bit code and here was a bunch of smartasses trying to push 64 bit processors 10 years before x86-64 became the flagship for Intel-compatible processors. During the time when 'Internet time' was a thing people said regularly and unironically. 10 years was forever.
We won't have to go to 128 bit processors for address space reasons. So I wonder what the justifications will be for doing so? And what features people will actually use it for when they have it? I suppose in some ways SIMD has skipped mostly over 128 to go to 256 and 512 bits though, hasn't it?
But I also know of 2 top-tier JITed languages that can use pointer packing to use 32 bit pointers for heap sizes under 32GB to save tons of memory. So 128 bit words would make pointers obnoxiously expensive.
Now, HP’s PA-RISC chips…. Those things were fast and easier to work with. Curiously, with SoftPC they could do windows faster than a 486 could. Slaughtered all sorts of mini-supers they did.
Would have been interesting if alpha survived to compete with SGI’s MIPS.
Alpha was much more sophisticated but also a lot more complex. The Alpha memory model, in particular, was quite complex with lots of cache control and barrier primitives, IIRC. But it could fly when you got the stars to align.
Edit: Alpha also came out later and PA-RISC also got more complex in later generations.
See: ftp.parisc-linux.org/docs/arch/pa11_acd.pdf
Edit: actually, it did have fixed point multiply via the floating point unit (opcode XMPYU). No fixed point divide, though.
Looking at the alpha architecture manual, the fp emulation traps are imprecise, which imposes constraints on codegen to make it work right: the "trap shadow" extends from the potentially trapping insn until a following trap barrier, and in the shadow you mustn't e.g. use a register more than once as a destination, have a branch, or modify registers that are inputs to any insns in the shadow. (The idea is that the hardware will have already executed some of the insns in the shadow by the time it realises it needs to trap, and the handler has to be able to emulate the trapping insn and resume execution at the insn just after that, so it will re-execute all the insns in the shadow.) That's obviously pretty inconvenient for codegen, so I wouldn't be surprised if the compiler provided some kind of fast-math mode where it didn't trap and you just had to avoid generating denormals, infinities, etc.
I think making the fp using code have to be written carefully to work with the software emulation of edge cases is unusual -- I don't think either sparc or arm imposed that requirement, and instead trap precisely, or at least before anything happens where it would matter that the fp insn is emulated late.
who knew? (everyone)
The last line of the parent post makes it sound as if the chips didn't exist at the same time.
https://en.wikipedia.org/wiki/DEC_PRISM
Killing Prism sent David Cutler into the arms of Microsoft.
Another dead architecture was Jupiter: https://en.wikipedia.org/wiki/Jupiter_project
Killing Jupiter sent many of DEC's DECsystem-10 customers to IBM.
Years later, they both seem like bad decisions.
with hindsight it is funny to realize that RISCs come back would start from inside that highly specialized market in the form of ARM.
[1] - Though not exactly since they're all ARM ISA at the foundation.
Without AMD rescuing x86, PowerPC wouldn't have died. MIPS wouldn't have died, and faces with the need to brake the 4Gn barrier on consumer equipment microsoft would have had windows running on three or four competing architectures until 2013 when everything would have switched to ARM.
Itanium would have already been a rotting corpse.
AMD rescued Intel from its own management.
WindowsNT is remarkably well suited to porting to other arch. This was done on purpose to hedge against x86. Dead one day, reactivated the other. MS needed to brake the 4Gb barrier and they would have done anything to get consumer priced 64bit chips.
Itanium was a dog. We had an Itanium SGI "supercomputer". Everything about it that SGI designed was amazing (hot swapping cpus). The cpu was a dog.