More specifically a Holtek HT32F. There’s one in my AMD Wraith Prism CPU cooler that does nothing but control the pretty RGB LEDs. Was wondering how this compared to my old 486 DX-2 50. Or my family’s 286 or Apple IIC. Or the computers we went to the moon with.
Chances are your coffee maker has a more powerful computer than the one that we went to the moon with.
I’m not familiar with the HT32F off the top of my head. ARM processors in general are very fast integer processors, so like your Apple IIC’s processor they can’t do floating point math. Some have an FPU available, I’m not sure if the HT32F has one. Considering what they are using it for, I doubt it.
The Apple II used a very simple processor with no pipelining or anything like that. So to execute an instruction, it had to go through numerous steps. First it had to fetch the instruction, then decode the operands, then run the instruction through the ALU, and finally write out the answer somewhere (exactly where depends on the instruction). This is simplifying a bit, but that’s the basic idea.
The 80286 had a little bit of pipelining in it, but not much. Pipelining is when a processor has different stages, and each stage does one thing and then passes the data along, so the data flows through the stages, kinda like stuff flowing through a pipe (hence, pipelining). The 486 had a much better pipeline.
Pipelining was invented by RISC processor designers. The idea was to reduce the instruction set (RISC = reduced instruction set computer) so that each instruction could be broken down and executed quickly through a pipeline type architecture. x86 processors are definitely not RISC. They have very complicated instruction sets, but Intel could see the benefit of pipelining, so they borrowed a lot of ideas from the RISC folks.
In a typical RISC pipeline, there’s one part of the processor that all it does is fetch instructions. It then sends those instructions down the pipe where another part of the processor does the operand decoding. Meanwhile, while the decoder is doing its thing, the fetcher is fetching another instruction. The decoder then sends the decoded instruction to the ALU. The ALU executes the arithmetic/logic of the function, while simultaneously the decoder is decoding the instruction the the fetcher had just fetched, and the fetcher is grabbing a third instruction. So basically by breaking things up into chunks, the processor isn’t waiting for one stage to finish, and instead of taking half a dozen clock cycles to execute a single instruction, a RISC pipeline, once the pipe is filled, can execute on average one instruction per clock cycle, even though each instruction may take several clock cycles to execute as it moves through the pipeline.
ARM processors are RISC machines. They execute very simple instructions very quickly.
If you want to do something where all of the data you are dealing with is just integers, then an ARM is going to run circles around a 486. It’s not even a close race. The 486 is going to end up looking silly.
But, if you need to work with floating point numbers, the 486 DX has a floating point co-processor built in. The ARM doesn’t have the ability to natively handle floating point numbers, so it has to emulate floating point math, which is really, really, really, really slow. Where the 486 would just issue one instruction, the ARM would have to do everything in software, using dozens of instructions.
If you want to control a bunch of LEDs, an ARM processor is fine for that. LED arrays are just integers that you output to the LED controller, so an ARM is probably overkill for an LED controller. ARM processors are also what you often find inside of network switches and routers. They can move integer data around very quickly, much faster than a 486 computer.
But if you are trying to render a 3-D image, an ARM can’t do the floating point math, so it’s performance is going to suck horribly.
I found a page indicating your processor achieves up to 90 MIPS on some benchmark, and another page listing a 66 MHz 80486 DX2 getting 35.3 on the same benchmark. So it’s already more than twice as powerful as the 486 when run at full speed/power. But you don’t need full juice to blink some lights, and maybe the cooler builders could have saved a few milliwatts by using something even more minimalistic.
ETA the benchmark in question is an integer benchmark