I believe that Kevin and Stefen have brought=20 up very good points. If we

need to provide fine granularity control for SystemVerilog = processes=20 then

these mechanisms need to be intuitive, general, and robust.

After reviewing Kevin's proposal I came up with the = following=20 proposal.

Process Control

Use the process keyword to denote a = new=20 built-in class. This way, users = can

declare objects of type process and safely pass them = around through tasks or

incorporate them into other objects.

Objects of type process include several built-in=20 methods:

task terminate - = Terminates the process

function int status -=20 Returns process status (0 dead, 1 ready, -1 created, 2=20 waiting...).

(A cleaner way = might be=20 an enum but that would add top-level identifiers)

task suspend - = Suspend=20 execution of the process (process is still ready)

task wait - Wait = until=20 process terminates

The key to the process class is that (a) it's an = object and=20 therefore subject to

the same type-checking rules = as other=20 objects, (b) it can be garbage collected

like any other object, and (c) it's a built-in = class, and only=20 the fork..join construct

creates these types of objects. The statement = "process e=20 =3D new()" could be

disallowed altogether, or it could be used to = retrieve a=20 handle to the calling process.

Also required is an atomic mechanism for assigning = all=20 process'es created by = a

fork..join. Atomic means a mechanism whereby=20 all processes are initialized before

the calling process or any of the sub-processes has = had a=20 chance to execute and

perhaps terminate. One way to provide for this = would be=20 to modify the grammar of

the fork construct to accomplish this:

process=20 pids[*];

pids =3D fork

p1();

  p2();

  p3();

join any

// user implementation of fork ... join =

// and terminate all remaining processes.

// Like a priority fork .. join

for( int i =3D 0; i < = pids.size; i++=20 ) begin

    if( = pids[i].status !=3D=20 0 )

    =    =20 pids[i].terminate();

end

The example shows using a dynamic = array to=20 receive the process objects, but one

could also use a fixed-size array (i.e., = pids[1:3]). =20 The basic concept is that the pids

array is initialized by fork before any of the sub-processes begin=20 executing. This way

the parent process, or any of the sub-processes has access to all = the=20 process objects

and avoids a situation where a process executes and terminates = before one=20 has had a

chance to monitor the process externally.

Also, by making this an explicit part of the fork..join, the = compiler can=20 decide if all the

process objects are needed and optimize accordingly.

Arturo