HN Simulatornew | past | comments | lists | submit | phire's commentslogin

I'm not sure we would have found this impressive back then, the output is pretty nonsensical. Back then, we had other (more manual) approaches that could produce somewhat equivalent results.

It's a bit of an illusion, it looks quite impressive to us because we know how good the output from a full-sized LLM can be. We are willing to give it a lot of leeway because of its small size as long as it produces output that looks kind of like chatgpt.

Well... computational linguistics academics should have been impressed at how well it understands language with nothing more than ingesting a huge amount of untagged data.


In fact, I know for a fact we wouldn't, because... This existed.

Well, not something made the same way this was. And yet, still precisely this in nature. There was at one point a website with what was basically a chatbot pretending to be God. It had pretty evasive responses, very frequently got off topic, but sometimes, and I am not sure how they technically achieved it, it would give spot on answers to what you told them. Never deep trivia knowledge, but like, casual talk expressions and very simple queries, and other follow ups that made complete sense. Like it would know how to follow up on a "What's up dog?" and bark as a joke when you tried to say "I meant dog literally".

And crucially: We found it utterly unimpressive. It was a stupid toy for kids in computer class.


Heuristic Pattern Matching via AIML. Probably a variant of ALICE

https://en.wikipedia.org/wiki/Artificial_Linguistic_Internet...

So not even comparative to be honest.


The technology wasn't comparable. But IMO the result for a typical end user was roughly the same.

Sometimes they would produce wonderfully on-topic responses, and other times they would go off the rails. And the end user would only tolerate so much off-the-railsness before dismissing the product as pointless.

Yes, the results here are quite a bit more impressive than historical equivalents if you analyse them at an academic level. But that doesn't matter to an end user.

And we saw the same with LLMs. Most people completely dismissed LLMs like GPT2/GPT3, despite how much progress they were making. It was only once OpenAI successfully made them follow instructions and wrapped it up as ChatGPT that the general population started paying attention. GPT3.5 wasn't any smarter than GPT3. But everyone perceived it as smarter simply because it could follow instructions (which... brings up some interesting questions about humans)


> Shouldn't those "µops" be the ISA?

Well... that is the pure RISC philosophy from the 80s.

But there are advantages to having a disconnect between the encoded instructions and μops. So much that most "RISC" ISAs have instructions that are explicitly intended to decode to multiple μops. ARMv8 takes this approach pretty far, with quite a few instructions that are explicitly intended to be split into multiple μops.

Hell... Even RISC-V has begrudgingly expermented with the idea: See the Zcmp/Zcmt extensions which are explicitly defined to decoded to multiple 32-bit instructions; Or arguably the Zaamo Atomic instructions, which are part of RVA23.


This disconnect is really light compared to x86_64 mess (status register on out-of-order CPU).

The transition is going, if any, will be tough: basically you would need a "x86_64" hardware 'slow' mode, on the side of the 'clean' and light RISC one.


Condition codes are not hard to do on an OOO machine. I know that there are RISC books that say there, but they are not.

z/Arch, x86, ARM, PowerPC, and SPARC all have condition codes. They all have OOO implementations and all but SPARC have really, really fast implementations.

---

µops are not at all like RISC instructions. They tend to be quite big, for example, or have really strange encodings (that vary from place to place inside the CPU). A group of 2-4 µops may share a single wide literal field (or bigger literals will be encoded with a number of µops or something else crazy).

Pentium Pro (P6) had a µops length (at some point inside the CPU) of around 115 bits, for example.

µops also typically expose the pipeline(s) to some extent which is just ugly and very, very for from being clean.


> know that there are RISC books that say there, but they are not.

You don't have to look far, the RISC-V spec makes this incorrect claim.

> µops are not at all like RISC instructions

Yeah. Zen μops are actually documented to be variable length (at least when stored in the μop cache, but presumably elsewhere). And μops hold both a memory load and an ALU operation... very CISC.

It's only the full read-modify-write instructions that still get split into two μops. And I doubt it's actually two fully independent μops, because seems a waste to send the instruction through the AGU twice.


Much content on HN says the opposite: "a status register on OOO is disgusting". Should not have been there in the first place, but x86_64 has too much toxic legacy. Namely, you have to pay with serious implementation complexity that legacy for high performance.

And RISC-V as its sweet spot roughly set for implementation simplicity, namely some core design choices show a strong difference here.

Obviously µops are encoded specific to some µarchitecture, but their "operations" may tell us what would be a "good" ISA for performance, and many seem to agree that this ISA would be "RISC" based. This what I intended to say.


> Much content on HN says the opposite

Doesn't mean they are right. It's mostly just RISC-V fans blindly repeating the RISC-V justification for not having flags without understanding the situation.

And it's only RISC-V (and MIPS before it) which sticks to this position. Most other high-performance RISC arches have flags. Including ARMv8, a complete departure from 32-bit ARM, and one which was explicitly designed with high-performance OoO cores in mind. ARMv8 dropped many fun RISC features from Arm32, but they kept flags.

Really, the cost for flags on OoO cores isn't that high. You have already implemented everything you need to rename regular registers, which you can reuse to implement flag renaming too. It costs a tiny bit of area and maybe a little routing complexity, but doesn't have any impact on fmax.

> but their "operations" may tell us what would be a "good" ISA for performance, and many seem to agree that this ISA would be "RISC" based.

Well... given that the current μops of x86 cores aren't RISC-like, (because they are variable length, and aren't load-store), your suggested philosophy would not result in a RISC-like replacement ISA for x86.

Like, the weaker form of your argument is probably correct. If we were designing a replacement x86 ISA, then the current μops of various x86 implementations would be a good inspiration for informing what that ISA could look like.

It's only the strong form that I disagree with: There is no good reason for any ISA to be a 1:1 mapping of the μops it decodes into. And there are many good arguments for not doing that. μops can be arbitrarily wide, as they are only used for internal purposes. Instructions need to be dense and compressed, as code density can have a large impact on performance. There is no good reason why a single instruction shouldn't decode to two or even hundreds of μops... that's just good compression.


> Really, the cost for flags on OoO cores isn't that high. You have already implemented everything you need to rename regular registers, which you can reuse to implement flag renaming too. It costs a tiny bit of area and maybe a little routing complexity, but doesn't have any impact on fmax.

I generally agree, but want to point out that they aren't "free" either. Look at contemporary wide OoO Arm cores, most (Apple Silicon, C1-Ultra, ...) have half the throughput on flag reading/writing instructions than the equivalent instruction without the flag write (ADD vs ADC vs ADDS). So clearly the cost is high enough to drive towards such tradeoffs being made.


Yeah, not free.

I'm only really arguing that handling flags in OoO designs doesn't require massive amounts of extra "complexity", which is the common argument.

They don't argue that flags add area, or power consumption. Just an unreasonable amount of extra design complexity (and maybe a FMAX limitation) to the extent that OoO μarches would be far better with flags not existing.

Of course flags uses more area (though IMO, probably not much that area). And if it uses area (even a tiny bit), then engineers are probably going to spend time optimising it. Even tiny savings can be put to use elsewhere.


Indeed, zero area is better than "small area" to work around a performance bottleneck.

Even one is too many.


But it's not a performance bottleneck.

Flags are a performance advantage. RISC-V needs extra instructions to do the same thing as ARMv8. Or sometimes the same number of instructions, but the compare-and-branch is more heavy (instead of reading an independent 4-bit flags register, it needs to tie up the register ports to do full sized register reads and run compare).

And ARMv8 can use the flags registers to reduce contention on GPRs, while RISC-V is sometimes forced to waste GPRs on emulating flags registers. And it does take a tiny bit more energy to write to a 64-bit register than a 4-bit one.

There are a few cases where compare-and-branch is more optimal than seperate compare and branch instructions... But ARMv8 gets the best of both worlds because it has a set of compare-and-branch instructions too (though some implementations will split that into two μops)

The major advantage of flags is that they give you certain three-input instructions (cmov, addc and ccmp) without requiring a proper three-wide register file.

TBH... I'm not entirely sure the amount of area spent on implementing flags actually provides more benefit than the cost, that would be next to impossible to prove. But they certainly provide more than zero benefit, and IMO it's a quite large advantage.


As said by others on HN, on performant µarchitectures it seems to require significant complexity to fit into the 'standard' optimizations those µarchitecture does, and the one which is often put forward is out of order exectution.

> Doesn't mean they are right. It's mostly just RISC-V fans blindly repeating the RISC-V justification for not having flags without understanding the situation.

It seems it comes from some CPU designers which have that understanding: for performant implementations, not having a status flag would remove some significant complexity from the way. Having a status flag is said to make classic performant implementation more complicated, and newer ISAs removes that (RISC-V is one of them). And this is only one design choices, I guess they made many others which were done in a similar fashion.

Yeah, I actually meant the distance between µops and the "operation" should be reduced in order to avoid implementation complexity. This statement was not to be taken as verbatim, my bad. The thing is how much of the bad from some ISA legacy did infuse in those µops.


> It seems it comes from some CPU designers

It comes from CPU designers who don't have a history of making OoO designs. Designers who love making high-performance area-optimised in-order RISC cores. CPU designers who created RISC-V.

I mean, I design CPUs too, (as a hobby) so why not take my word?

RISC-V is not a modern ISA. It might be a new ISA, but it's very much a design stuck in the late-80s. It's basically just "MIPS, but with the benefit of hindsight". They didn't get rid of flags because that was the modern approach, they just blindly copied what MIPS already did in 1984 and tried to come up with a post-hoc rationalisation for it.

Don't get me wrong, RISC-V is not the worst ISA. It does a good job in its intended use-case (of being a great university ISA, easy for students and hobbyists to implement themselves. Or a starting point for weird cores with lots of custom vector instructions). It's just not a modern ISA.

If you want to see an actual modern ISA, take a look at ARMv8.

ARMv8 was designed around the same time as RISC-V, but by professional CPU designers. It was a joint project between ARM Inc and Apple. Those Apple engineers were working on what later became the M1, and the ARMv8 ISA shows very clear signs of being optimised for modern very-wide OoO cores.


Weird, you are the only and first one to say that from my point of view. Maybe "modern" is not the right work, maybe "not legacy" should be used instead.

I code RISC-V assembly and I coded ARM assembly, RISC-V is just a leaner and cleaner version of ARM, aka RISC (without IP lock... which is why new and small manufacturers do prefer RISC-V over ARM).

It seems RISC-V does a good enough job at reducing the amount of work to design high performance implementations (it seems the companies doing that are bought by ARM dominant corpos... to kill them or absorb them... the future will tell). Of course it is all about sweet spots and tradeoffs, for instance RVA is getting some heat about the RISC-V compressed instructions which seems to require significantly more work for high performance µarchitectures.

Many are waiting for those RISC-V high performance µarchitectures on latest silicon node (if they are not mostly bought to be killed).


You clearly missed the recent "RISC-V: They Should Have Known Better" blog post [0] and associated HN comments [1]. Though, criticism goes back much further (like this post [2] from an ex-ARM engineer).

> RISC-V is just a leaner and cleaner version of ARM, aka RISC

But does leaner and cleaner actually result in better performance? And really RISC-V is only lean and clean if you ignore all the extensions. With extensions, it's doing many of the same things as ARM.

And IMO RISC is legacy (or at least that lean-and-clean version of RISC is), we are actually in a post-RISC era where massive out-of-order μarches absolutely dominate the high-performance computing space.

> without IP lock...

Yes, that is the major advantage of RISC-V, along with extensibility.

And TBH, it's good enough for many usecases.

One thing that the massive dominance of x86 over the last 30 years should have taught us, is that ISA doesn't matter anymore. The modern post-RISC Out-of-Order paradigm allows us to complexly detach a legacy ISA from the internal μarch and make it run really fast despite all the legacy issues.

[0] https://dmitry.gr/?r=06.%20Thoughts&proj=12.%20RV

[1] https://news.ycombinator.com/item?id=49298035

[2] https://gist.github.com/erincandescent/8a10eeeea1918ee4f9d99...


« ISA doesn't matter anymore. The modern post-RISC Out-of-Order paradigm allows us to complexly detach a legacy ISA from the internal μarch and make it run really fast »

But apparently it doesn't allow it to run really cool, thermally speaking: ARM has an edge over x86 for mobile. Is that a difference that is independent of µarch? If so, what is it down to, provided it can be expressed in reasonable simplicity?


It's mostly independent. Intel did have its Atom line of in-order low-power processors.

As far as I understood, it is the RISC-V compressed instructions which adds significant complexity for performant µarchitectures. There were many threads about RISC-V (ofc, there is a lot of ARM dependent zealots working hard at FUDing RISC-V) where it was put forward.

The point is to reduce the implementation complexity required to achieve 'classic' high performance. This is very important for new µarchitecture designers.

In other word, you get 'classic' high performance more easily, faster with less work to do, and I guess this has been one of the main drivers for RISC-V design (and the fact the ISA is not IP locked).

I read it here that some RISC-V performant/large µarchitectures did add the complexity required to work around the compressed instructions, but it took them a while, and that would not have been required without the compressed instructions (this is not really RISC-V but "RVA"). Some CPU designers say it would have been the same mess with a status flag while implementing OoO performance.

And I am talking about 'implementation complexity' to achieve classic high performance: we all know that with enough complexity and additional work you can work around many performance bottlenecks, but it will "cost" each time.

RISC-V designers did try hard to design their ISA to reduce the road torwards high performance, with more or less success.

In other words, what the RISC-V designers seemed to have achieved: you need "less " to reach high performance, but this is not perfect.


> You have already implemented everything you need to rename regular registers, which you can reuse to implement flag renaming too. It costs a tiny bit of area and maybe a little routing complexity, but doesn't have any impact on fmax.

Renaming the condition codes separately from the registers seems to be the current fashion but it is not the only way.

The Intel P6 kept the condition code outputs together with the register outputs from the ALU -- so it would rename the condition codes and registers together.

However the renaming is done, it is abundantly clear that it can be done. We have 30 years of CPUs in the hands of customers that do it, and they do it fast and using very little area.


RMW memory instructions are actually pretty nice (and totally counter to the RISC philosophy).

Not only are they compact, they also make it crystal clear that the cache line in question should be marked exclusive as soon as it gets read.

The x86 does not have that much implementation complexity. There's the complexity you always get from high-performance implementations, but Apple, ARM, and IBM pay for that, too. The main issue is that there's just a lot to implement and verify.


And if I am not too mistaken, many RISC-V design choices were made to remove that complexity (to bring saner high-performance silicon... and that without IP lock).

Must be RDS.

Checking wikipedia, there is optional support for transmitting time and date in RDS, with an explicit usecase of updating the clock in cars.

> I also wonder why cars with built-in GPS navigation don't synchronize their clocks using the time from the GPS signal.

GPS doesn't transmit timezone information, nor does it transmit leap seconds. It transmits a very, very accurate UTC minus 18 seconds, but without access to the internet for timezone database updates or (until recently) leap seconds, it's a bit useless for updating a clock.


Since it also provides fine grained location info, with a TZ database it is going to be dramatically better than what is going on.

Then just let the user override TZ offsets or the like if they want.


I think now that leap-seconds are gone, the built-in TZ database approach (with user override) becomes a lot more viable.


I'm not sure if you guys read the article, but OP's car does use GPS for the time, applying a user-settable offset (or in OP's unfortunate situation, a fixed offset).


GPS doesn't but Galileo, GLONASS, and BeiDou all do (no idea about Michibiki). Are car receivers still GPS only these days?


The 360’s GPU was very modern, but I’m hesitant to give the 360 the “modern design” label because of how esoteric those CPU cores were; And the major hoops developers needed to jump through to get them preforming at peak performance, along with offloading work to the GPU.

They had SMT, but unlike every other implementation of SMT I’m aware of, memory stalls on one thread would stall both threads… which kind of defeats the primary purpose of SMT.

At least with the PS3’s Cell, the SPUs were designed to be esoteric on purpose. It seems like Xenon kind of just ended up being esoteric by accident. (Or maybe they ended up like that because Microsoft were cheating off Sony’s homework)


IME SMT is approximately useless if your code is any good and you have one obvious source of load (the foreground game, a trading engine, etc). I just reduce thread count to at most the number of physical cores if my software is the dominant workload. How did developers typically work around that xbox deficiency?


The DAO incident was a special case. It was only sane to do the rollback because the stolen funds were time-locked up for 28 days.

Ethereum never did it again, rolling back hacks didn’t (and couldn’t) become normal policy. IMO, they shouldn’t have made an exception, as it set a bad example.

I’ve seen a few other small projects attempt to do rollbacks since, but it usually turns into some kind of mess. In most hacks, the coins aren’t time-locked and quickly get laundered through smaller exchanges (and other services) which act as mixers. The stolen coins end up in the hands of a bunch of innocent people, and the rollback then causes way more harm as those users lose their coins.


Perhaps because in all following hacks none of Ethereum members as a whole participated unlike DAO incident.


The video has structures fading in and out of existence, which is a pretty typical artefact found in many AI video models.

That's not quite enough to prove it was AI in itself. But when combined with the fact he was unable produce the original raw grayscale video and how he deleting his linkedin... basically confirmed to be AI.


> The original SimCity for example lists Intel’s 386SX as the CPU in it’s system requirements.

Not sure where that comes from. The original release box art [1] says it will work on any PC with 512KB of ram. So that's an 8088 running at just 4.77 MHz.

But that's far from the lowest spec port of the game. The Commodore 64 version might have been missing quite a few features (like stadiums, police/fire stations and railways), but the main city simulation loop was there in just 64KB of ram and a 1MHz 6502.

And the BBC Micro/Acorn Election port was even more impressive. Had basically all the features of the full Amiga/PC/Mac version, only missing Music/Sound/Animation. With a 2Mhz 6502 (or 1Mhz on the Election) and just 32KB of ram.

[1] https://images.launchbox-app.com/79861ce4-75ea-46dd-b46e-521...


And I was expecting a lot more detail from the OP article considering it made the HN front page, but it pretty much comes down to, the game works on a 16-frame cycle, where 1 cycle it may handle crime stuff, another frame handles fire and disaster stuff, etc. No more details about what happens within 1 of those frames, or anything else, beyond 5 cycle function names. And the source is at https://www.donhopkins.com/home/micropolis/


The original release was for Amiga and Mac. The C64 version followed around the same time as the PC version, though apparently the C64 version was the original.


C64 was not a port. The C64 version is the original.


I was running Sim City 2000 inside Win 3.1 on an 386 with 33MHz (I had 16MB of ram though). But it was virtually unplayable.


Sim City 2000 is a very different (and computationally more demanding) game than the original Sim City.


In my youth, people would quit Windows 3.1 to run games in DOS, because the overhead of the OS was too much.

Don’t know if that could be an explanation.


Definitely that was often a solution, but the version I had didn't run on DOS. Not sure whether this was a windows only version I had. Often the problem was ram, extended memory often didn't really work on DOS.


One had to do some significant hand tuning of config.sys and autoexec.bat to optimize conventional.memory usage for a lot of games in that era (ie. relocating device drivers to extended memory), at least until later versions of MS Dos included the memmaker utility to partially automate the process.

This was tricky enough that folks would pay my barely adult self a consultant's hourly rate to do this for them.


It ran great on a Performa 475 (25 MHz Motorola 68LC040). I guess that settles that old debate!


I think it’s really obvious that the ps6 won’t have an optical drive.

IMO, the main reason Sony are discontinuing ps5 disc manufacturing now is so by the time they get around to launching the ps6, the move away from optical discs is old news. They know the move is unpopular and they don’t want the drama associated with the launch of their new console.

I’m less sure about what will happen to bluray movies. But this is not a good sign.


Based on this NSA documentation [1], they didn't actually synchronise the clocks with each other. They just tuned each machine's quartz oscillator with the nearest national time source. They were mostly dialling in the oscillator frequency here, not the exact time, so it didn't really matter they were synchronising to different national time standards.

Besides, even with the automated start system, the actual spin-up time of the turntables would have been a little chaotic. I suspect they were only aiming to get the four turntables within about 100ms of each other. The decrypted signal itself could then be used for the final fine-tuning of the timings (which also included adjusting for any speed-of-light delays)

If you weren't within 20ms, the operator would only hear noise (like a radio). Once they were within ~20ms, the operator would start hearing silence and would tune the phase until all noise went away.

You don't really need exact synchronisation because like a radio, the operator could just scrub the tuning to find the silence.

The synchronised clocks meant that once the operators had locked on, it would stay locked for a long time.

[1] https://www.nsa.gov/portals/75/documents/about/cryptologic-h...


Also, just because the jury didn't think there was enough evidence to convict her of defrauding patients (beyond reasonable doubt), doesn't mean she was innocent.


It actually does. You can judge her, but she is not guilty. The more we as a society decide the justice system is just an arbitrary way of deciding who gets punished and not _the_ way of deciding if a person is or is not a criminal the more we slide towards oblivion.

If a person is found not guilty, they are not guilty. To argue otherwise is to undermine the core institution of western civilization.


Important to note that western civilization is fundamentally ok with the knowledge that the statement issued by a jury or judge does not actually define whether a person is morally, factually or colloquially “innocent”. Disputes may be addressed c/o OJ Simpson and the Central Park 5.


Not guilty doesn't mean innocent. It means "guilt could not be proven", it does not mean "innocence was proven".

Seriously, this is why OJ was found liable for the murder of his wife in a civil case, as they're judged on the balance of probabilities.

And it's why people who have served time, then had a retrial ordered and then found not guilty, can be denied compensation, because decisions on compensation are also done on the balance of probabilities.

So yeah, "not guilty" != "innocent".


The finding is ‘not guilty’, rather than innocent. It does not mean the accused is innocent. It means they could not be proven guilty.


Important to note that in the original conception of western civilization, no one is 'innocent'. This idea that you have some secret special power to sniff out a persons true heart from a distance, which is separate from a jury of a persons peers studying and debating the evidence, is at best misguided and arrogant, and at worst a pernicious threat.


Don’t overcomplicate it. People are discussing their opinions of truth, using relevant terms.


No. To argue what you argue is to play pretend stupid.

Court of law with its ability imprison people must have higher standard for the "guilty" decision. That makes it possible for rich guilty people to not be judged guilty.

You are allowed and expexted to use own brain. You can consider people guilty.


I mostly agree with the idea, but to accept this as an absolute implies our justice system is infallible


there is no way to argue that without also believing that the millions of people the state has tossed into prison are all guilty, which is really not something that I can do.


Not guilty != innocent.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: