* a data-dependent fail-first sv.cmp tests against
  a[i] <= m.

* SVP64 Branch new CTR Mode would loop back over all elements that
failed, decrementing CTR in the process.

* a data-dependent ffirst sv.cmp a[i] > m creates a predicate
  mask where VL is truncated to exclude the first failed
  element.

int m2(int * const restrict a, int n) 
{ 
    int m, nm; 
    int i; 

    m = INT_MIN; 
    nm = -1; 
    i=0; 
    while (i<n) { 
        while (i<n && a[i]<=m) 
            i++; 
        if (a[i] > m) { 
            m = a[i]; 
            nm = i; 
        } 
        i++; 
    } 
    return nm; 
}

bug 
https://groups.google.com/g/comp.arch/c/5h6jzyESg5s/m/FiMO3falAgAJ

while (i<n) { 
    while (i<n && a[i]<=m) 
       i++; 
    if (i < n) { 
       m = a[i]; 
      nm = i; 
    } 
    i++;
}

alternative?

while (i<n) { 
    // skip up to first max
    while (i<n && a[i]<=m)  i++;
    // continue as long as picking new m
    while (i<n && a[i]>=m) { 
       m = a[i]; 
       nm = i;
       i++;
    }
}

changing milestone to match parent task for budget allocation

(In reply to Luke Kenneth Casson Leighton from comment #0)

this one is remarkably simple: use the characteristics
of mapreduce mode to overwrite nm from a parallel
comparison

> int m2(int * const restrict a, int n) 
> { 
>    int m, nm; 
>    int i; 
> 
>    m = INT_MIN; 
>    nm = -1; 

first prepare offsets

    setvl vl=16
    sv.svstep *offs, srcstep # 0 1 2 ... vl-1

and nm-potential

    li nm, -1
    li nmbase, 0

next use CTR mode

>    for (i=0; i<n; i++) 
>    { 

    setvl r1,0,16,0,1,1 # VL=r1=MIN(MAXVL,CTR)

perform the load of the vector data, post-increment update:

     sv.ldux/pi *a, 8(a_ptr)

>        if (a[i] > m) 
>        { 

get max comparison, overlap-loop into m where reg a=m+1

    sv.max. *m, *a, *m

next, these two both use mapreduce mode with predication

>            m = a[i]; 

    sv.ori/mr/m=gt m,*a,0

>            nm = i;

add-overwriting base with vector-offset into nm, yes *scalar* nm,
the "last winner" is the largest index

    sv.add/mr/m=gt nm, nmbase, *offs

>        } 

nmbase must be incremented by vl

    add nmbase, nmbase, r1 # r1 contains copy of vl

branch and subtract VL from CTR if not end of loop

    sv.bc/all 16, *0, loop

>     } 
>     return nm; 

    mr r3, nmbase
    blr

the trick here is the multiple overwrites of nm and m, even though
they are scalar, the usual "termination of looping because scalar result"
is switched *off* in mapreduce mode.
thus due to the predication the last successful conditional overwrite
"wins"

the second trick was to use a base nm which increments by VL, from a
vector of sequential constants.

there will be better/other methods, using data-dependent failfirst
will stop at the first compare-fail but will need "continuation"
(2 nested loops) whereas the mapreduce one is really simple but
relies on WaW hazards to be eliminated

we now have "sv.maxs." which should do nicely to get the maximum *and* notify
(Rc=1 vector) whether the max occurred (combined cmp function).  if predicated
with a prior scalar-vector cmp, although there would be two vector compares it
would reduce the amount of interdependencies (except on a pre-sorted list)
see bug #915 about combined cmp function

also from strncpy, load-post-increment

  48                 # load VL bytes (update r10 addr)
  49                 "sv.lbzu/pi *16, 1(10)",

there is another technique which will work here: parallel-reduction
schedule in vertical-first mode.

the reason that vertical-first is needed is because in the middle
of the reduction the index has to be updated: it is 2 bits of
work not 1.

continuing
https://groups.google.com/g/comp.arch/c/5h6jzyESg5s/m/SNXgLyP8AgAJ