RE: [vhdl-200x] Re: TB: Execute procedure and return immediately

There is a parallel story in SystemC land ;-) First the addition of 
sc_spawn, which is pretty much the equivalent of fork...join_none, then 
the addition of a set of process control features, literally named 
suspend, resume, kill ...

What this says to me is that there is now a reasonably well-understood 
paradigm for dynamic process creation and interaction in languages in this 
space, with a lot of commonality between the realizations in SystemVerilog 
and SystemC. So purely in terms of harmonization between languages it 
would not be entirely unreasonable to add something very similar to VHDL. 
Of course, it would raise interesting questions about the VHDL network 
model, elaboration, and the run-time determination of drivers ...

Cheers,

John A




From:
"Peter Flake" <flake@elda.demon.co.uk>
To:
<vhdl-200x@eda.org>
Date:
15/11/2012 21:57
Subject:
RE: [vhdl-200x] Re: TB: Execute procedure and return immediately
Sent by:
owner-vhdl-200x@eda.org



Hi Martin,

In Verilog there was a fork/join construct, which allowed parallel
statements and waited for them all to finish, but it was not used much. In
SystemVerilog, this was extended to include the constructs of Vera.  'join
any' waits for any statement to finish, and 'join none' does not wait at
all.  The problem seems to be that once you have dynamic processes, you 
need
all kinds of features: name, list, suspend, resume, kill.

Such a major change needs a very good justification, in terms of a use
model, as Jim suggests.

Regards,

Peter.

-----Original Message-----
From: owner-vhdl-200x@eda.org [mailto:owner-vhdl-200x@eda.org] On Behalf 
Of
Jim Lewis
Sent: 13 November 2012 17:47
To: vhdl-200x@eda.org
Subject: [vhdl-200x] Re: TB: Execute procedure and return immediately

Hi Martin,
This is the classic C programming fork/join model to concurrent execution.
We are looking for a use model that justifies adding something like
fork-join to VHDL.

Many of the use cases are for actions that are independent, but need to be
synchronized upon completion.  Generally for these type of things, I use a
separate process for each independent interface/thread.  What I think we
need to do is to classify different concurrent communication methods and
create synchronization procedures for them.
I have some of these in my testbench utilities package.

interface1_thread : process
begin
   procedure_1(..., value, signal_a); -- execute procedure and return
immediately
   BarrierSync(thread1_2) ;
   ...

end process ;

interface2_thread : process
begin
   procedure_1(..., value, signal_a); -- execute procedure and return
immediately
   BarrierSync(thread1_2) ;
   ...

end process;

So we are still looking for the use model where we need to use fork/join
with a concurrent language.  I suspect it may occur in an interface that
supports both normal and split transactions.  Just have not looked into it
enough yet.

Best,
Jim


> Hello,
>
> during simulation I wanted to do something like this:
>
> process
>    procedure_1 (...,
>      signal value_proc: in integer,
>      signal signal_a_proc: out integer)
>    is begin
>      ...
>      wait for 10 ns;
>      signal_a_proc <= value_proc;
>      ...
>    end procedure_1;
>
>    procedure_2 (...,
>      signal value_proc: in integer,
>      signal signal_b_proc: out integer)
>    is begin
>      ...
>      wait for 20 ns;
>      signal_b_proc <= value_proc;
>      ...
>    end procedure_2;
> begin
>    -- execute the following two lines in parallel
>    procedure_1(..., value, signal_a); -- execute procedure and return
immediately
>    procedure_2(..., value, signal_b);
>    -- end parallel execution
>    wait;
> end process;
>
> In this example I have defined two procedures. These procedures could 
set
some signals following a certain timing. Now assume that the timing of the
signals set by the two procedures are interdependent. So what I want to do
is for example to start the two procedures at the same time, or to start 
the
second procedure a specified time after the first procedure while the 
first
one still hasn't finished exectuion.
>
> I'm not aware of a construct in VHDL which would allow this behavior.
Could this be something which can be considered for a future standard of
VHDL or would such a construct have too many unwanted side effects?
>
>
>
> Best regards
> i.A. Martin Stolpe
>
>
> ----------------------------------------------------------------------
> ------------------------------------
>
> Systemingenieur
> R&D Smart Embedded Systems (SW)
>
> NewTec GmbH
> System-Entwicklung und Beratung
> Heinrich-von-Stephan-Str. 8B
> D-79100 Freiburg
>
> Telefon  : +49 (0) 761 21117-40
> Telefax  : +49 (0) 761 21117-41
> email    : martin.stolpe@newtec.de
> web      : http://www.newtec.de
>
> ----------------------------------------------------------------------
> ------------------------------------
> Geschäftsführer: Johannes Werbach, Harald Molle, Ulrich Schwer, 
> Michael Tröscher
> Registergericht: Memmingen - HRB 7236 USt.-IdNr. DE130850199
> ----------------------------------------------------------------------
> ------------------------------------
>
>
>


--
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Jim Lewis
Director of Training             mailto:Jim@SynthWorks.com
SynthWorks Design Inc.           http://www.SynthWorks.com
1-503-590-4787

Expert VHDL Training for Hardware Design and Verification
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

--
This message has been scanned for viruses and dangerous content by
MailScanner, and is believed to be clean.



-- 
This message has been scanned for viruses and
dangerous content by MailScanner, and is
believed to be clean.





-- 
This message has been scanned for viruses and
dangerous content by MailScanner, and is
believed to be clean.