Is the Coldfire project dead?

[billt]

>As far as I understand, there is also a software-bit to the
>ColdFusion accelerators. There will be somekind of emulation
>made in software (on a ROM on the board) that will take care
>of this.

The "emulation" would be very very similar in concept to 68040.library or 68060.library. In fact, it's the exact same concept, but will probably need to trap and emulate more instructions than those libraries did. If they put it on the board and not in a file on disk, I sure hope they use a nice FLASH that can easily be rewritten with bugfixes and performance improvements.

[bloodline]

billt wrote:
>As far as I understand, there is also a software-bit to the
>ColdFusion accelerators. There will be somekind of emulation
>made in software (on a ROM on the board) that will take care
>of this.

The "emulation" would be very very similar in concept to 68040.library or 68060.library. In fact, it's the exact same concept, but will probably need to trap and emulate more instructions than those libraries did. If they put it on the board and not in a file on disk, I sure hope they use a nice FLASH that can easily be rewritten with bugfixes and performance improvements.

If the Coldfire doesn't trap 32-bit muls and mulu instructions then there is no way it could ever run Amiga software without something like a JIT... in which case using a modern RISC would be a better idea.

[jdiffend]

A Coldfire board for the Amiga is very possible.  Since the 4e core Coldfire chips are more compatible with the 68K series it's more feasable than ever.

However, there are some things that present a problem with the ColdFusion project.
1. Someone with no engineering background isn't likely to be successful their first time out.
2. You either have to emulate the 68K CPU entirely in software to use the existing ROMs or you have to rewrite at least a portion of the ROMs.

Full emulation of the 68K CPU isn't any better on a Coldfire than on a Pentium so why not just run an emulator on a PC?

Rewriting part of the ROM would let most instructions execute natively and instructions not supported by the Coldfire could be emulated by illegal instruction traps.  There are some instructions that CAN'T be emulated (see old threads if you want to know why).

This is NOT like the 68060.library!!!!  Yes, the 68060 library uses instruction traps... in that way they are the same.  But the current Amiga ROMs would fail within the first few instructions and you'd never get to load a 56xxx library.

The exec needs rewritten so that it is totally Coldfire safe and it needs to have the illegal instruction handler integrated into the exec.  Since the exec also uses timers, that should also be made coldfire safe.   After that the instruction traps would take care of MOST incompatibilities.  Some hardware drivers might need a rewrite as well.  

The best way I know how to do this and use the existing ROMs would be to have the accellerator start in it's own FLASH memory, copy the old Kickstart ROM to RAM (executes faster there anyway), patch it, remap the RAM to overlay the old ROMs (disable writes to the RAM while it's at it) and then reset to start the ROM image.  Like kickstart on an Amiga 1000 but with an additional step.
As time goes on more patches could be added or the entire ROM could be replaced.

The Coldfire CPUs handle non-floating point math the same as the 68K with minor exceptions which can be worked around with patches.  Replace the incompatible multiply & divide instructions with illegal ones that can be trapped and original behavior emulated.

The floating point math is WAY different and a new floating point library would need to be written.

And most importantly... if it won't run on a 68060... it probably won't run on a Coldfire.

[whabang]

Well, I hope Oliver can make this work. Such a card would be the only way I'd ever invest in Amiga hardware again... :-(

[Oli_hd]

Hi,

No updates for quite some time

Yep, im lazy, I did buy a new snazzy website which I intend to do sometime.. but I havent.
Im putting the finishes to a new prototype design.. why? well the current design should work (well I think it should) but it doesnt, so the new card is stripped down to the basics and has a socketed Coldfire, this should help me get the thing working.
I also have an A2K design finished which I will get printed but its a very basic design.

As for updating the website, yes I should do that, I really should do that......

[billt]

> If the Coldfire doesn't trap 32-bit muls and mulu instructions

Does it fail, or are you "if-ing" about hypothetical stuff? Id think that in trapping an instruction it doesn't have implemented, it wouldn't say anything about  afew certain functions like muls or mulu being non-implemented but not allowed to trap...

Does it not just say "I don't implement that instruction, I don't care what it is, just trap it."

[lordv]

[/quote]Does it fail, or are you "if-ing" about hypothetical stuff? Id think that in trapping an instruction it doesn't have implemented, it wouldn't say anything about afew certain functions like muls or mulu being non-implemented but not allowed to trap...

Everybody doubting please go to the freescale.com (former motorola) and find 68k software emulation library for coldfire, where it is written, that coldfire JUST WON'T TRAP on 32x32->64 mul, 64/32->32 div and 32/32->32:32 div instructions! Because they differ only slightly from 32x32->32 and 32/32->32, which coldfire supports. And coldfire just won't see any difference and execute them as 32x32->32 or 32/32->32. Unlike the 060, which will trap anyway.

This is a serious bug preventing virtually any 020+ program from correct executing. There are several workarounds, like a total JIT-emu of 68k code or hell MMU stuff like examining every codepage it's going to execute and see if there are such muls, but overall it will make coldfire even slower than 060.

FPU is also a pain, which probably won't work correctly anyway.

[lordv]

If the Coldfire doesn't trap 32-bit muls and mulu instructions then there is no way it could ever run Amiga software without something like a JIT... in which case using a modern RISC would be a better idea.

Yes, you're right. A g4-only accel card will be enough for everybody (whoops! . fast g4 (1ghz) could fully emulate 68k at the rough speed of 040 or 060 when no JITting. With JIT it will become the fastest 68k ever seen And you still have conventional amiga, not the pc-like monster (pegosos or amigaone, whose the only difference from pc is the powerpc processor). Optionally you can have on such an accel modern single-chip videocard (I don't understand why I could ever wish geforce4 on my amiga!).

[Effy]

About the lack of FPU, the Apollo 68060/75 Mhz also lacked an FPU but besides programs that needed it, the card was lightning fast, not ?

[Karlos]

lordv wrote:

Yes, you're right. A g4-only accel card will be enough for everybody (whoops! . fast g4 (1ghz) could fully emulate 68k at the rough speed of 040 or 060 when no JITting. With JIT it will become the fastest 68k ever seen And you still have conventional amiga, not the pc-like monster (pegosos or amigaone, whose the only difference from pc is the powerpc processor). Optionally you can have on such an accel modern single-chip videocard (I don't understand why I could ever wish geforce4 on my amiga!).

Actually, I have to point out that running interpritevly, the 680x0 emulation in OS4 is quite capable of reaching the same level performance on my 603e as the real 68040 on the same card. Naturally the actual performance depends on the task at hand - some oerations are considerably slower, others faster.

[Framiga]

by bloodline on 2004/11/19 10:30:41

Well Oli is still around, he is posting on the Vulcan website about that one that got sold on Ebay.

probably i haven't understood well but . . . what "about that one that got sold on Ebay"

Ciao

[Oli_hd]

probably i haven't understood well but . . . what "about that one that got sold on Ebay"

Ebay link to Vulcan

[billt]

I didn't realize that they had changes somewhat the results of certain instructions. That can make it more difficult than just being able to trap everything. But I doubt it's impossible. Come on, we've got the Amiga background, a tradition of doing the unnecessary, the bizarre, and the nigh-impossible.

No, it may not be easy, but if we all wanted to take the easy route we'd all be Windows users right now, wouldn't we?

[lordv]

I didn't realize that they had changes somewhat the results of certain instructions. That can make it more difficult than just being able to trap everything. But I doubt it's impossible. Come on, we've got the Amiga background, a tradition of doing the unnecessary, the bizarre, and the nigh-impossible.

For what is it worth to do impossible things with coldfire? It can't fully emulate 68k by trapping everything, so the only way is JITting. Then, JITting is more effective on ppc-g4/g5/soon. Exhaustively enough? =)

[Karlos]

Actually, JIT mechanism for 68K on coldfire need not be more complex than HP's Dynamo mechanism. That is effectively a hotspot JIT emulating the actual same CPU it is running on and gets faster performance due to various runtime optimisations that arent possible to make at compile time.

Like Dynamo, a JIT 680x0 on coldifre implementation has the benefit that most of the instructions would need no translation - you only need to worry about branch offsets that change as a result of expanding some code "inline", like your unimplemented 680x0 instructions.

[lordv]

Actually, JIT mechanism for 68K on coldfire need not be more complex than HP's Dynamo mechanism. That is effectively a hotspot JIT emulating the actual same CPU it is running on and gets faster performance due to various runtime optimisations that arent possible to make at compile time.

Like Dynamo, a JIT 680x0 on coldifre implementation has the benefit that most of the instructions would need no translation - you only need to worry about branch offsets that change as a result of expanding some code "inline", like your unimplemented 680x0 instructions.

Don't know anything 'bout dynamo (maybe some urls?), but with coldfire it's not that easy.

Just imagine - you have all regs filled with data and you must JIT-emulate add.w d1,d2. No stack push/pops are allowed by definition, flags must be also set correctly. The same but to a greater extent goes to mulu.l d1,d2:d3 or smth similar.

That's why I'm saying about g4/g5 JIT emulator as an accelerator for amiga. Unfortunately I have no needed knowledge to do such thing by myself.