Gold 2.7 release for the Vampire accelerators

[psxphill]

Not on this forum it seems. Other forums have already reported that the FPU implementation doesn't work properly.

For example, launch SYS:Tools/Calculator and try to calculate 5 * 1.3, and the result will be 6.499999999069.

More about issues in the FPU implementation over here:
https://blog.alb42.de/2018/03/03/vampire-2-7-fpu-part-2/

Assuming this is purely due to the cutdown 64 bit precision (rather than the full 80 bit precision of the 68881/68882/040fpu/060fpu) because the full 80 bit implementation takes too much FPGA space. Then you either have to wait for new larger Vampire FPGAs or for Gunnar to have an epiphany on how to make it fit.

It's possible it's a different issue, but supposedly you should only expect scene demos to look ok and not anything that expects the correct result.

This was already discussed on amiga.org before the release, nobody wanted to accept that people might expect correct results and that it would be a problem.

According to https://blog.alb42.de/2018/03/02/vampire-v2-7-with-fpu/ Apollo won't be compatible with any software that uses Round() until you can get a version that is 100% accurate.

"The Round() on 68k always uses a helper for now, because FPC's Round() is defined to return an int64 value (signed 64bit integer). This cannot be done by the hardware on 68k, so the code currently calls the round helper, which is a pretty big function, and depends on the IEEE bit-correct result of all operations, as it does some integer bit tricks on floats. (There could be some special cases added, when the expected integer result is less or equal to a 32bit signed int, but that's beside the point now.)"

[psxphill]

With the CPU installed, the quality is pretty poor. There are no "completely bogus" results as you could get with the pre-V45 releases (pow() returned pure nonsense in some cases), but rounding is bad and precision is bad.

Is that something you'd be willing to improve?

I'm unclear about the rest of the post what the cause of the FPU errors are that the guy is reporting. Is the calculator always broken with an FPU (my amiga is currently boxed away)

[psxphill]

because he can piss on other people's free work of an entire year...

It's not free.

[psxphill]

Oh, yes, it is. Firstly, this is not a paid update. Try replacing an LC040 for a 040 for free. And the price you pay is for the hardware, the core developer team hasn't got a penny.

Your argument might hold water if you could go out and buy a non vampire card and run apollo on it.

Can someone explain to me what white listing, mentioned on the fpu thread, is about?

[psxphill]

I am sorry for you, but somebody has then been making profit out of your free work for over a year: as we all know, Vampires arent sold at cost.

I hope you get some compensation for your work.

Maybe everyone should boycott buying vampires if Apollo development is slave labour?

Just because something doesn't cost, doesn't make it free. For example.

https://edition.cnn.com/2014/03/31/tech/web/gmail-privacy-problems/index.html

I assume Apollo developers think they will make money out of it eventually.

[psxphill]

Last time i checked we all did it because we like Amiga and wanted to bring something new and fresh for Amiga fans by Amiga fans.

Sounds great, I want in. Where can I download the apollo source?

[psxphill]

-- Troll mode on
  BS_ABOUT_EMULATION:         goLearnAboutWhatAFPGAIs();
[/CODE]-- Troll mode off

I know what an FPGA is & I know what emulation is.

Apollo is not a software emulator written for a general purpose computer, but that isn't all that "emulation" is.

You can emulate a cpu with 74ls chips if you really wanted. http://www.baltissen.org/newhtm/ttl6502.htm

[psxphill]

No, the correct technical term for this would be "implement".

Only if you don't know what emulate means.

emulate: "reproduce the function or action of"

How you emulate something, whether it's an fpga, software, hardware, pieces of string etc is an implementation detail.

It seems emulation is a pejorative term, so nobody wants anything to do with it & comes up with reasons why their emulation is not emulation. It's all just PR & spin.

Emulation in hardware has been around for decades. Sound cards featured sound blaster emulation, hercules graphics cards had MDA emulation.

[psxphill]

As people defaults Emulation as something to do with software,

Only because that is what is being told to them.

Having to use synonyms because of someones ill advised PR strategy, is a pain.

It's emulation, it's different from emulation in software. Just focus on the benefits, rather than turning it into another ist of prejudice and discrimination.

i.e. Lower latency because of dedicating gates to logic, rather than the multiplexed gates in a cpu that are decided by the cpu.

[psxphill]

You clearly have no clue. A CPU built from discrete gates IS a CPU and thus not an emulation. Hence, it is _implemented_ using gates, not emulated.

If I make a real CPU which emulates a 6502, it's emulation. It's not a real 6502.

You are emulating an idiot. You're still a real human being.

Does CR-RW emulate CD-ROM? That's FPGA is, a CD-RW. And 080 is a 68k CPU.

CD-RW and CD-ROM are actually quite different in their properties & have no logic. It's quite a crazy analogy, a real straw man. But in keeping with media analogies, Alot of Compact flash cards can emulate IDE hard drives. SATA controllers can emulate IDE controllers.

It's no different to sound blaster emulation or epson printer emulation back in the 1980's. Those were also real hardware that weren't running a software emulation.

The linux x64 and m68k vary from each other at the edge of precision, even both should get the same result (x64 always do 64 bit calculation with SSE2/3, m68k always do 80 bit) and I guess thats what this define is all about.

I work on a big software project and we've recently ditched x87 support on our 32 bit builds because the precision was different to the sse used in the x64 builds. We lost support for a few cpus that were still technically possible to run, but the results are now the same.

[psxphill]

A "real CPU that emulates a 6502" would be e.g. a i7 running a VIC20 emulator. If the "real CPU" executes 6502 code natively, then you  _implemented_ a 6502.

If you make something capable of running 6502 programmes using TTL then it most certainly is not a 6502.

If you take the 6502 decap and use the die shots to make masks & run a chip fab in your kitchen then you can claim to have made a 6502. Anything else and it's just pretending to be a 6502, AKA emulating.

A hardware emulation is still an emulation.

[psxphill]

Aha. So if I built my 6502 as a silicon chip without looking at the 6502 die and by accident came up with the identical netlist as what you consider a 6502, what would it be? Emulation or the real thing? Seems to be some philosophical straw you are clutching at.

You're the one that is trying to break my argument by using stupid philosophical arguments. It's impossible that you will happen to create an identical mask without referencing the original.

Which "6502" is the real one that you need to decap to make your own one?

It depends which behaviour you want, it's often important to get the correct one for your application.

By your definition everything but the 1975 die ones are just pretending to be a 6502 AKA emulating one I suppose? :rofl:

No, that is by your definition. I don't consider someone speaking to be doing an impression of themselves, even though over time you have cells die and new ones grow & are no longer the exact same person with the exact same abilities.

Going back on topic. VHDL is a language, like any other programming language. It allows you to control the gates in an FPGA, like you can control the gates in a CPU. You can implement a 6502 in C running on an x86 or implement a 6520 in verilog running on an fpga. Both are emulating certain behaviours of a 6502.

BTW, nobody claims the 68080 was a Motorola 68000, 68010, 68020, 68030, 68040 or 68060, remember?

https://en.wikipedia.org/wiki/Ship_of_Theseus == strawman, got it?

[psxphill]

And you clearly want to remain ignorant about the subject you are commenting on. But I guess this is as close to admitting you were wrong and have no arguments left as your personality will ever allow you to get.

The only thing I admit to is letting you troll me with your straw men.

My point is clear, your religious hatred of the word emulation is making you unable to see it. So much so that you apply magical qualities to the word implement.

But I guess you have your reasons. I'll let you get on with pretending that emulating a CPU in an FPGA isn't emulation, if it makes you happy.

If you ever are interested in a reasoned debate then I will consider it, but I very much doubt that your personality will ever let that happen.

[psxphill]

BTW, this clearly demonstrates that you don't know what you are talking about. VHDL is not a "language like any other programming language". It is a _hardware description_ language, not a _programming language_.

I don't get how you can argue that a Language used for Programming is not a programming language.

Field Programmable Logic Array. VHSIC Hardware Description Language

VHDL borrows heavily from the Ada programming language in both concepts and syntax.

It's like saying that you could write a true equivalence of Shakespeares body of work in Inuit because it is just another language like English is.

No, that would be a straw man. A common occurrence in your attempts to derail any discussion.

This particular one seems to be aimed at https://en.wikipedia.org/wiki/Turing_completeness

One to start with is that there is no concept of parallelism in any of the programming languages I'm familiar with

That is your ignorance showing. Not all programming languages are procedural.

With OpenCL you can:
 Leverage CPUs and GPUs to accelerate parallel computation
 Get dramatic speedups for computationally intensive applications

https://developer.amd.com/wordpress/media/2012/10/OpenCL_Parallel_Computing_for_CPUs_and_GPUs_201003.pdf

Over time it's likely we'll see more software switch to GPGPU https://en.wikipedia.org/wiki/General-purpose_computing_on_graphics_processing_units
To the point that WinUAE will have some of the same advantages as an FPGA emulation of a 68k amiga (eg generate the video on the graphics card to remove a layer of latency in the OS).

That is also why you need a high MHz CPU interpreting foreign CPU code of a 6502 or 68k while you only need an FPGA running at 80 MHz to exceed 68060 speed as demonstrated by the Apollo Core.

Sure. I understand that, but it doesn't solve any issue of whether that is emulation or not. We know that dedicating logic gates to a particular task has a greater efficiency than time sharing them. It's an implementation detail.

[psxphill]

The latter is microcoded, the former is not.

Whether it's microcoded or not is an implementation detail. Whether a 68060 was emulating a 68000 is up to Motorola to decide, like Ship of Theseus.

A 65816 can emulate a 6502. A NEC V30 can emulate an 8080.

The chip is "real enough" for many users. Probably not for my use case, but that's a different story and not related how you call it what it does.

As Winuae is real enough for many users, both have pros and cons in their implementation. Saying it's not emulation is an attempt to create a religious following that overlooks the downsides, because "it's always better because it's not emulation".