Can you even believe that we are nearing 11 months of active genocide and the only thing that’s changed is how much people care and are interested in being advocates for Gaza (I am watching you all lose interest in Palestine with my own eyes)
October 7, 2024 will be here before we know it and suddenly everyone will be talking about Palestine again because it is the “one year anniversary” and there will be a million articles and posts and think pieces about how we as society have let this happen for 365 days straight. And then it will turn October 8 and everyone will go back to pretending this genocide isn’t real
I don't mind Apple products and the various tradeoffs that come with them, but if you hate them, I have good news for you. The reviews are coming in and at long last it seems like Qualcomm is making chips that can actually stand their ground against Apple's: if you get a laptop with a Snapdragon X Pro/Elite chip in you'll finally get the performance + ludicrous battery life that the Apple people have been lording over you since 2020.
It's so good, genuinely have been waiting forever for a good ARM laptop to the extent that I presently own a bad ARM laptop.
re AMD and Intel, they both have ARM divisions that I expect to see doing more server stuff, although they are in a much worse position than if this happened 10 years ago and haven't kept up with some of the more dedicated ARM designers, and much more business software is open source and will port trivially to ARM as compared to back then. Also I expect we'll see Nvidia's ARM chips cropping up more and more, one of my predictions is that in 1-2 games console generations we'll see an ARM xbox/playstation perhaps even with Nvidia graphics now that they could OEM the whole package very easily, which used to be a big AMD strength.
I do think that this is going to basically eat the laptop market once it trickles down though, and Qualcomm has finally actually tried to mainline these chips so even Linux will work. They've been mainlining the 7c for a while, which is what's in my bad laptop, and it's mostly all there (although video decoding does not work very well :( )
So, if you casually search for the answer to this you unfortunately mostly get platitudes and horseshit. I am not an experienced processor designer so I can only offer you one step up from platitudes and horseshit. With that said:
The basic processor you learn about in school is a very simple machine, the idea is that you have memory somewhere, and at t=0 you start reading the first instruction in memory, do what it tells you to do, and then the next one, and then the next one. Sometimes an instruction will tell you to read a value out of memory, or write a new one into memory, or jump the execution to a new point, or do something with the values you've been manipulating.
x86 and ARM represent Complex and Reduced Instruction Set Computing respectively, CISC and RISC. RISC and CISC are somewhat distinguished by how many instructions they have, with RISC generally having simple, composable instructions, whereas CISC has more, special-purpose instructions, especially when you count "mandatory" or "core" instructions.
These are not hard-and-fast categories but for all but the most niche architectures most people agree on which are which, for reasons which might become apparent if I do a good job here.
Most instruction sets, even RISC ones, have a ton of performance-enhancing extensions that can operate on wide vectors and do other accelerated operations, so the overall instruction counts can be closer than you'd expect. There are still noticeable differences though, for example, a minimal ARM processor has to implement a couple hundred instructions, while a minimal x64 processor has to implement well over a thousand. A minimal to-spec RISC-V32 processor has only 47 base instructions.
In your toy baby processor, you execute one instruction at a time. The school version of this is the Fetch/Decode/Execute/Store cycle. You fetch an instruction from memory, decode it, execute it in your logic units, and then store back the results. In practice what this means is that at any moment, three of the four major components of your system are sitting idle, so we start pipelining. While one instruction is being executed, the one after it can be decoded, and the one after that can be fetched. If it turns out that the execution of the current instruction requires a new instruction to be executed, we stall the pipeline until we catch up, losing some performance in the moment but still gaining overall.
This is a good start, but there's another issue, which is that individual instructions do not all take the same amount of time to execute. CISC systems often begin with a dream of having really, really fast useful instructions that can be deployed by just using the right instruction call, you know, oh this popular encryption method uses an operation where we fold a number back on itself eight times and XOR it, so let's just do that in hardware. You can also think of it as a way to shrink code, if you have a microcontroller that can do a multi-step operation in one instruction.
Unfortunately very quickly you run up against limitations: implementing hardware logic for all your thousands of instructions uses up valuable silicon space, and a bigger chip is more expensive for several reasons (greater susceptibility to flaws and errors, lower yield per wafer, etc.)
So we do microcode. Microcode is when your processor contains a second, secret processor to do the actual work. When an instruction like "fold a number and XOR it" it comes along, a smaller, simpler processor that is maybe more like a pile of state machines and ALU's can be manipulated by a hypervisor built into the chip to execute the effective results of the intended instructions in a couple of cycles, generally (but not always) faster than a naive implementation but much slower than dedicated hardware.
If you want to know more about microcode, check out this C3 talk that goes into great detail about the x86 microcode, especially the front half.
This is slower than if you had huge expensive dedicated hardware, but you can shrink your dies to resuse hardware for multiple operations, and you can now pipeline microarchitecture-based operations to try and make up for it, squeezing multiple operations into your multi-purpose hardware. Intel started using microcode-like designs with the P6 architecture in the mid-90's, I mentioned this in my list of cool chips:
What are some of the coolest computer chips ever, in your opinion?
Hmm. There are a lot of chips, and a lot of different things you could ca
This has some weaknesses though. If your CISC instructions are too complicated, they can start to become highly non-deterministic, they can take multiple cycles to execute, and now you need to dedicate a lot of processor design and effort to optimizing the pipelining and microarchitecture of these instructions to make more efficient use of your limited silicon. You leave yourself open to weird stalling and wasted compute cycles, and you spend a lot of silicon tracking all of this state and shuffling microoperations to try and make them run smoothly. Eventually you're spending so much silicon on managing microarchitecture that you lose any of the benefits you got by doing it
RISC systems generally don't do microcode in the conventional sense, because their instructions are so limited that you can kind of (do not say this to a processor designer) think of them as being microcode already. You compose the operations together into the end result you want at compile-time, rather than fussing around with stupendously complicated CPU designs.
Because of this, the individual instructions are much more deterministic and break down into pipelineable operations much more cleanly, so when combined with your compile-time optimizations you don't have as much work to do at runtime, you can use relatively simple pipelines and still get high utilization and lower waste on less silicon.
The end result is that you can shrink your silicon, reduce your complexity, while still maintaining performance parity with the CISC processors, because you're both doing the same kind of thing. Less silicon and higher utilization means better performance within a smaller power envelope, you physically have fewer transistors to switch and they're not being left idle for as long.
So why didn't we just start with RISC? Well, historical reasons mostly I think. CISC makes programming in assembly easy, because it hands the programmer nice "functions" built right into the silicon, and it trims program size by packing long operations into a single instruction. CISC comes from an era where optimizing your CPU to make assembly optimization easier and shaving some bytes off code by packing operations together made sense, and that wasn't the best idea. This article roughly agrees with me
Okay, so far I think most of this is pretty rock solid. This is where I talk out of my ass for a bit: The way I think about this is as the benefit of having insight into the purpose of code up and down the execution stack.
In CISC, you write some code, and your optimizing compiler will assemble it as best as it can to use these really big instructions. Those then get executed onto a CPU that has no idea what that code was, and why it is laid out this way. Your CPU now has to try and use lookahead and other tricks to just guess what you were trying to do, and then pipeline the microoperations that make up your compiled code. If it guesses wrong, the pipeline stalls, stuff has to bubble through, branches fall apart, and you waste a bunch of time computing microoperations that were unnecessary.
In a RISC, you do a lot of this ahead of time. You write your code, and your optimizing compiler can strip out huge chunks of your operations at compile time, if it determines that half of those "microoperations (not that)" are not actually needed. It knows where return values end up, what gets written to memory, and so on. When the code gets to the CPU, it has already been corralled into a nice format for the CPU, which you know a fair amount about, you know what instructions it has, you know how it pipelines because your instructions are simpler, so you can feed it really nice easy to optimize code, and it has a pretty good idea about what all those instructions do because they're very simple, if it didn't need to do them they would have been stripped out at compile-time, and it can focus on just executing what it does get very efficiently.
The result of this is that RISCs are very popular in the modern day, where compilers are good, no one really writes much assembly, and a few dozen extra kilobytes of instructions in a program is fine. You can save power and silicon space while still getting high performance by optimizing your pipelining with simpler operations that increase processor utilization without requiring complex babysitting hardware to oversee the pipeline.
i promise you that person on fent bent over + swaying in rags is having a worse couple hours than you've ever had in your entire life. i promise you that person begging for money on the subway is going throughs something 1000% worse than you having to avoid their eyes while going to a restaurant. i swear on my life that person talking to themselves in public isn't evil or the devil or going to kill you. i think you need to get the fuck over yourself and stop acting like you're suuuchhh an NYC native and being afraid of all drug-heavy areas and posting videos of people on the trains like "only in the city! lol!". i think you should learn how to either have some compassion or shut the fuck up
So… people didn’t know that Biden’s claim to fame during the 80s was that he was noticeably to the right of the Reagan administration and they had to publicly move right to avoid attacks from other Republicans along the lines of “see? Even Democrats are harsher than Reagan”.
The Democratic Party should just be fed into a wood chipper because, on the “the purpose of a system is what it does” basis, it is always so obvious that the purpose of the party is to push everything rightward while pretending that it’s accidental. The party’s leadership went all-out to make sure the most right-wing candidate got the nomination in both 2016 and 2020, and Democrats were fine with that.
germansingergirl
yousharknotpass
snowghoul
izzy806
theartofmadeline
kaledo-art
dailybridgerton
gummygunk
