Z80 v 6502 can be seen as being similar to a RISC v CISC debate - link
. The 6502 is not exactly a RISC processor, but it does have a much smaller instruction set than the Z80. The 8088, which became a big winner when IBM selected it for the PC in 1981, seems to have been a compromise between the two.
Quick note: some of the Z80 advantages over the 6502 don't relate to the instruction set - e.g. extra registers, which, without doubt, reduces the number of memory fetches needed to get a result.
RISC has made a big comeback in recent years in the form of ARM - a world-beating RISC architecture widely used in portable devices due to its low power requirements (CISC computers generally draw their power from wall sockets).
Also, Seymour Cray, a brand name supercomputer engineer, and other supercomputer suppliers, tended to favour RISC: the reasons are complex, but seem to come down to this: supercomputers are complex machines that use a lot of energy, so best make them out of simple components that don't use much energy. Cray also realised that most of the instructions in a CISC are not used very often in numerical programming.
To try to simplify a complex issue, here's a short list of the strengths of each architecture (bearing in mind that I'm not an expert). Looking at this list, I can see why Clive Sinclair chose the Z80 for his ZX80 device
, which was big hit in the UK - the first home computer for under £100:CISC
* smaller programs (especially valuable in the early days of home computers which had very little RAM)
* programs easier to build and maintain (this would only apply to developers working in assembly - but some early chess programmers actually did work in assembly, and at the time, this would have given them a big speed advantage IMO)
* speed: having complex instructions will mean that fewer instructions will need to be executed to get the same result
* memory access is better (some CISC instructions can directly access memory!)
* easier to design and build the rest of the computer (link
* a compiler will be less complicated (obviously this advantage only applies to people who write compilers)RISC
* higher raw speed
* lower power consumption (e.g. the SOC featured in the OP which runs on milliamps)
* most instructions completed in a single clock cycle (meaning that the speed of code execution is all down to the skill of the author of the compiler: these days, there are many compilers that are able to produce efficient code)
* probably better when building a system that uses multiple CPUs (e.g. Cray supercomputers). This is a guess on my part - I don't really know - but it is a fact that it's what Seymour Cray used to do