Non-ALU operations shouldn't count toward FLOPs

[wilswu99]

Examples of current behavior:

n = 10
A = we.randn((n, n))

we.copy(A)   # 0 flops
we.concatenate([A, A],)    # 2 * n**2 flops
we.stack([A, A]),   # 2 * n **2 flops
we.broadcast_to(A, (n, n, n))  # n**3 flops
we.fill_diagonal(A)    # n flops. NOTE: this contradicts the docstring at whest/src/whest/_free_ops.py:930

It's odd that copy is free but the rest are charged. I propose making alll non-ALU operations (including all operations above) free.

[spMohanty]

Agree that the current state is inconsistent, and we should unify it.

I think the root problem is not any single op, but that we do not yet have a shared guiding principle for deciding when an op should be free vs counted. So rather than decide this one op at a time, I’d think it will help if we can agree on the guiding framework, and then classify the affected ops against that framework in one coherent pass.

We agree that whest FLOPs is a competition-oriented analytical cost metric, not a literal hardware instruction counter.

My suggestion for the classification system is:

1. Free: ops whose output is determined by shape, dtype, axis, scalar parameters, or fixed structural movement, and that do not inspect values or use runtime masks / index arrays to select or route data.
2. Counted: ops that inspect, compare, rank, count, search, summarize, or route based on values.
3. Boundary ops get explicit rules: if an op does not fit cleanly, we should document it explicitly rather than forcing it into the wrong family.

To make this concrete, I generated the op lists below from the current registry. The lists below are intended to be exhaustive for the top-level helper surface I think is in scope here.

I am intentionally excluding:

• module-prefixed namespaces like linalg.*, fft.*, random.*, stats.*
• clearly numerical kernels like add, multiply, divide, matmul, einsum, convolve, corrcoef, etc.
• blacklisted I/O / config / system helpers

Proposed buckets for discussion

1) Pure structural / metadata ops - proposed default: free

Creation / passive materialization / deterministic structural generation

append, arange, empty, empty_like, eye, from_dlpack, frombuffer, full, full_like, identity, indices, linspace, meshgrid, ones, ones_like, zeros, zeros_like

Shape / view / broadcast / structural composition

array_split, atleast_1d, atleast_2d, atleast_3d, block, bmat, broadcast_arrays, broadcast_shapes, broadcast_to, column_stack, concat, concatenate, copy, dsplit, dstack, expand_dims, flip, fliplr, flipud, hsplit, hstack, ix_, moveaxis, permute_dims, ravel, require, reshape, roll, rollaxis, rot90, row_stack, split, squeeze, stack, swapaxes, tile, transpose, unstack, vsplit, vstack

Diagonal / triangle / index-shape / metadata helpers

can_cast, common_type, diag, diag_indices, diag_indices_from, diagflat, diagonal, fill_diagonal, isdtype, isfortran, isscalar, issubdtype, iterable, may_share_memory, min_scalar_type, mintypecode, ndim, promote_types, ravel_multi_index, result_type, shape, shares_memory, size, tri, tril, tril_indices, tril_indices_from, triu, triu_indices, triu_indices_from, typename, unravel_index

2) Value-dependent helper ops - proposed default: counted

Predicates / comparisons / inspection

all, allclose, any, argwhere, array_equal, array_equiv, asarray_chkfinite, count_nonzero, equal, flatnonzero, greater, greater_equal, in1d, isclose, iscomplex, iscomplexobj, isfinite, isin, isinf, isnan, isneginf, isposinf, less, less_equal, logical_and, logical_not, logical_or, logical_xor, nonzero, not_equal, signbit, trim_zeros

Routing / gather / scatter

choose, compress, extract, mask_indices, place, put, put_along_axis, putmask, select, take, take_along_axis, where

Ordering / search / set / counting / nonlinear value selection

argpartition, argsort, bincount, clip, digitize, fmax, fmin, histogram, histogram2d, histogram_bin_edges, histogramdd, intersect1d, lexsort, max, maximum, median, min, minimum, nanargmax, nanargmin, nanmax, nanmedian, nanmin, nanpercentile, nanquantile, packbits, partition, percentile, quantile, searchsorted, setdiff1d, setxor1d, sort, sort_complex, union1d, unique, unique_all, unique_counts, unique_inverse, unique_values, unpackbits

3) Boundary ops - need explicit per-op rules rather than a family-wide default

array, asarray, astype, copyto, delete, fromiter, insert, pad, repeat, resize

For example, pad is boundary because some modes are structural and some are not:

• structural-ish modes: constant padding, reflection-style padding, wrap-style padding
• value-computing modes: maximum, mean, median, minimum, callable padding, and likely linear_ramp

4) Nearby ops I would keep counted and not treat as ambiguous in this helper-boundary discussion

Nearby ops I would leave counted and keep out of the ambiguous bucket

apply_along_axis, apply_over_axes, average, fromfunction, geomspace, logspace, piecewise, ptp, trace, vander

Concretely, I think we should

1. First agree on a variation of the framework above.
2. Then agree on the default buckets.
3. Then resolve the boundary bucket explicitly.
4. Review the sheet me and paul were using for calibrating the weights - so its in sync.
5. After that, do one coherent implementation pass across:
   • registry
   • runtime wrappers
   • generated docstrings
   • public docs
   • tests

That would fix the current copy / concatenate / stack / broadcast_to / fill_diagonal inconsistency, but also help us avoid a constant per-op whack-a-mole.

Let me know if the framework makes sense, and if you feel strongly about any of the bucket assignments.

[wilswu99]

The framework and the bucket placements make sense to me.
Re: the boundary bucket, my inclination is that casts should be free. I think this means that everything except pad in that bucket should be free (unless I'm missing something?)

pad is a little annoying. One possibility is to just re-implement it using we operations, and reuse the flop counting from those? I think that means

• constant, edge, symmetric, wrap, empty are free
• maximum, mean, median, minimum, linear_ramp, <function> are charged