All Does Not Always Mean All

When you use one of the stepping commands, TotalView determines the scope of what runs and what stops by looking at the thread of interest. This section looks at the differences in behavior when the a (all) arena is used. Here is what runs when you use this arena:

Specifier	Meaning
aC	Specifies all threads.
aS	Specifies all threads.
aW	Specifies all threads in all workers groups.
aL	Specifies all threads. Every thread is a member of a control group and a member of a share group and a member of a lockstep group. Consequently, three of these definitions mean "all threads".

Here is what some combinations mean:

f aC dgo

Runs everything. If you are using the g command, everything after the a is ignored: a/aPizza/17.2, ac, aS, and aL do the same thing. TotalView runs everything.

f aC duntil

While everything runs, TotalView must wait until something reaches a goal. It may not be obvious what this thing is. Since C is a process group, all processes run until at least one thread in every participating process has arrived at a goal.

Since this goal must reside within the current share group, the command completes as soon as all processes in the thread of interest's share group have at least one thread at the goal.

Notice that the thread of interest determines the goal. If there are other control groups, they do not participate in the goal.

f aS duntil

This command performs identically to f aC until because, as was just mentioned, the goal for f aC until and f aS until are the same and the processes that are in this scope are identical.

Notice that there could be more than one share group within a control group. However, these other share groups do not participate in the goal.

f aL duntil

While everything will run, it is again not clear what should occur. L is a thread group, so you might expect that the duntil command will wait until all participating threads arrive at the goal. TotalView defines this set of threads as just those thread in the TOI's lockstep group. While there are other lockstep groups, these lockstep groups do not participate in the goal.

f aW duntil

While everything will run, TotalView will wait until all members of the thread of interest's workers group arrive at the goal.

There are two fundamental distinctions between process group and thread group behavior:

• When focus is on a process group, TotalView waits until just one thread from each participating process arrives at the goal. The other threads just run and TotalView does not care where they end up.

  When focus is on a thread group, every participating thread must arrive at the goal.

• When the focus is on a process group, TotalView steps a thread over the goal breakpoint and continues the process if it isn't the "right thread".

  When the focus is on a thread group, TotalView holds a thread even if it isn't the right thread. It also continues the rest of the process. This behavior only exists on systems that allow TotalView to have asynchronous thread control.

With this in mind, f aL dstep does not step all threads. Instead, it steps only the threads in the TOI's lockstep group. All other threads run freely until the stepping process for these lockstep threads is occurring.