Help What's the difference between low level and high level emulation?

[Ikagura Ikagura]

I heard about it but could somebody summarise it a bit for me because I'm confused.

 

[Iguana-0]

I guess high level is more CPU consumption? I dunno i only emulate 8-16 bit games.

 

[Yousef]

I heard about it but could somebody summarise it a bit for me because I'm confused.

Are you referring to high end rigs? Are you someone who emulates on consoles rather than PCs? If so, that’s a bit out of my expertise but here’s my own two cents:

• low end would be most 2D consoles
• Low-to-mid would be the above plus low end polygon systems like 5th gen consoles and psp
• Mid range would be around ps2 and dolphin
• Mid to high would partially include 7th gen consoles
• High is debatable because ps3 emulation is only taxing because ps3 core itself is complicated, there’s a great video on it I advise watching
• Hope this helps ?

 

[AzzurraIrisLeaMonde]

low level emulation is more accurate so uses more resources
high level emulation is less accurate so uses less resources
it's like in programming languages

https://emulation.gametechwiki.com/index.php/High/Low_level_emulation

 

[G.L.a.D.O.S.]

Basically it boils down to.
Low Level - Aims for high accuracy and fidelity to the original hardware, often requiring detailed knowledge of the hardware architecture.

High Level - Typically faster than low-level emulation because it avoids the need to simulate hardware in detail; it can take shortcuts based on the software logic.

 

[NatalieZaki]

i thought this thread said something completely different, but what it means is how closely it matches the original code. For example, an emulator might use an OpenGL or Vulkan rendered instead of the system's own rendering system. This means that it will run faster, since your pc doesnt have to translate the code and render within the limitations of the console, however, this will lead to some inaccuracies, which might show as weird looking polygons or weird looking lighting.

 

[AnonymousCookieMonster]

Answers on here feel very vague.

The first emulators you will get usually are low-level, these are literally looking up the instruction sets, finding opcodes, and then doing lookups. Depending on the complexity of the instruction set can make for....... very hard to read code.

So typically brackets [ ] is memory access, and a switch case is used to match an exact number/ID and then run code accordingly. So you'd get:

char memory[]; //loaded or filled out later.
int ip; //instruction pointer
switch(memory[ip]){
   case 0: //add instruction
   case 1: //sub instruction
   case 2: //jump instruction
   default: //catchall, usually undocumented or unsupported
}

You then simulate the changes from each instruction call 1:1.

Higher level emulation like JIT literally will recompile. It may do the first pass similar to above, but then write to a block of memory the equivalent instructions in native code making a second pass on the code lightning fast.

The differences being to emulate via interpretation is usually about 200x slower than hardware, while recompiling or other more recent methods may be say 5x slower.

As for games using GPU's, the emulator acts as a pass-through and interprets, then rebuilds the calls to call to DirectX/Vulkcan/OpenGL letting it wash it's hands of those details rather than fully emulating the video half as well.

edit: Upon further reflection, the c/switch case example is probably considered interpretation rather than low-level in terms of how it's emulated. I was considering the complexity of making the emulation and how it worked vs faster more advanced methods.

 

[_oBSOLEte_]

If I understood correctly low level would be next to what FPGA aims to reproduce. For example, music from the emulator being reproduced with accurate synths having the same behaviour than the real hardware. High level in this scenario would be to just use samples recorded from the real thing, to gain some performance.

 

[Amag0k1]

Low level i assume means closter to hardware, and high level means it needs an inturprator.... Wait am i thinking of programming?

 

[AnonymousCookieMonster]

Low level i assume means closter to hardware, and high level means it needs an inturprator.... Wait am i thinking of programming?

Close... With programming you have:

BareMetal: Assembly, powerful, fast, exactly what you want.... and you're on your own.

Low-level: Simple instruction set but nothing happens outside what you give it. C is a good example because most instructions translate close to 1:1, you just let the assembler determine the exact opcodes.

High-Level: More complex features operation overloading, instantiation, auto memory allocation and garbage collection, etc.

Interpreted: Simpler languages but may offer some more complex features. BASIC being a classic. Curiously BASIC would bytecode compile the lines as you typed them and then run them from the bytecode. Regardless you can't run the program without the interpreter. AHK, Python and a ton of others fall in this camp.