Re: [oc] Re: Merlin Hybrid System

["Jim Dempsey" <dempsey@northnet.net>]

----- Original Message -----
From: "Steve Wilson" <stevew@intrinsix.com>
To: <cores@opencores.org>
Sent: Thursday, December 06, 2001 6:21 PM
Subject: Re: [oc] Re: Merlin Hybrid System
> Crusoe gets around this by Just In  Time compilation of the thread it's
running.   If you come up
> with a new architecture, you do JIT for that new architecture.  An elegant
solution really to the
> VLIW dead-end problem.
>
> VLIW compiler technology tries to keep the maximum number of execution
units busy for a given
> thread of code.  Nominally this means finding the inner-most loops of code
fragments and
> scheduling different interations of the loop across the different
execution units so they can run
> in parallel.  So - in away, the JIT compiler DOES have to understand part
of the code, but in a
> peep-hole fashion.  The fact is that VLIW can parallelize some algorithms
that other architectures
> like Vector processors can deal with.
>
> So - if Mr. Dempsey's idea can lie on-top of the above frame-work, all the
more power to him.
>
> Steve Wilson

You are starting to hit the nail on the head. JIT compilation is the core of
the process.
Wherein the "source code" is the x86 binary code. JIT can derrive an
understanding of the
code by examination. It doesn't have to be told. This is not unlike an
experienced
parallelizing programmer taking someone's code that they know nothing of and
parallizing
it. If a programmer can do it a program can do it.

The simplest of the examples I can use for illustration is at the point of
seperation
of a single execuition stream into a multiple execution stream. Assume the
instruction
sequence

    bla
    bla
    bla
    blink
    bla
    bla
    bla

Assume at point blink an interrupt occures.

    bla
    bla
    bla
    blink------------->
            blankity
            blankity
            blank
    <----------------
    bla
    bla
    bla

 Depending on the circumstances of the interrupt one processing
"strand" could continue execuition of the bla's during the interrupt.
The process I've developed would permit this to occure to some
degree.

As the complexity of the programming demands increase the continued
execuition yields greater returns. There are more complicated situations
where you can unroll loops and/or execuit multiples of the iterations
of a loop concurrently.


Jim Dempsey


--
To unsubscribe from cores mailing list please visit http://www.opencores.org/mailinglists.shtml