GitLab

Splits support for using tbb (oneTBB now) between OS's when using
std::execution::par

It appears TBB support seems to wane in earlier versions of g++ in CentOS and
other OS's still require testing/containers to verify builds.

The MIGraphX shim should just operate as normal with copy_if and sort() calls
if TBB support isn't functional for the current OS/g++ version

Also moved the TBB dependency from install_preqs to Ubuntu Docker. Shouldn't breka
other dockers if support isn't added

Don't reinvent the wheel, just use std::greater<****> since it mirrors the
behavior of the previous priority_queue we replaced here.

These still seem to stall. Commenting out to make sure we can get a proper
CI run of this.

This wasn't sorting correctly without this and failing other tests.

Remove's caching from this and may lead to errors down the road

Already installed via install_prereqs.sh for libtbb-dev

Allows us to continually filter out the top value as a pop when performing the copy_if
just an index after.

Offload these calculations when the batch box is created since we're now
copying by value, no need to recalculate these parameters.

Reduces the work repeated for the top_box selected but still leverages parallelism
for each subsequent box compared as our lambda in copy_if calls batch_box()
prior to suppress_by_iou

Make copies here since we're doing this calc in parallel

Less code, simple to read.

need to support std::execution::par used for parallel computation support.

This reverts commit aa91c4db7551ad69b6141597483d7c980d40d466.

- Add support for TBB in MIGraphX
- Add include for TBB in DockerFile
- Replace inner loop with copy_if and use std::execution:par to filter
- Change heap to vector and sort in parallel in filter_boxes_per_score()

With the help of Paul this cuts down NMS in ref from around 43-44s to about 2s

This cleans up the compute_nms signature as well as stops using additional
memory by not storing every pair result twice that just gets cleared per run each shape_for_each()

Allows us to transform to get the proper input then spawn a thread to call
f() in a threaded fashion. Useful if we have many batches/classes for our
runs.

This avoids us performing N comparisons for the given batch if the score
threshold used is less than zero. This allows us to simply just std::transform
all boxes without needing to perform a bunch of needles compares and use
constructs a std::pair of box score, idx directly.

Remove the need to use gpu, switch this to ref.
change names to reflect static vs random data

In this case we have a batch size with no bound on the score threshold.
We end up evaluating a single huge batch on its own.

The concern here is this should just all the way through without completely
stalling or intractably running in a single thread fashion currently.

This saves us two copies of the entire box class to this call and instead
works on reference of these objects that are created within the loops instead

We're continually creating/destroying batch box in the while() check as we
run through the boxes_heap() by calling batch_box() constantly.

Make this next_box and only calculate it before we pop that box from the boxes_heap.

should get rid of function overhead of constant calls in the case of a large
batch size

Just quickly return if either boxes have zero area. Searching for intersection
and union is irrelevant here logically.

Expose the shape::type_t values to be used by the python api and is required by torch_migraphx to support torchbench models.

This removes the --cxx flags from the rbuild commands since it is not necessary. Also added a section about using rbuild to set up an environment for development.

Adds a matcher to split_single_dyn_dim to find all broadcast or multibroadcast with two static shape inputs and replaces the instruction with the one input version.
Sorts the get_output_parameters() list to ensure the correct ordering. (Was getting an error for some models.)

* Enable hiprtc by default

Converts can be inserted when the scales and input differ in the onnx file(we are already doing this implicit conversion in the ref implementation). This will also improve the compile-time of quantizelinear.hpp since we can remove the nested visit method.

Examples..

bin/driver verify /codes/onnx_models/resnet50-v1-7/resnet50-v1-7.onnx --split-single-dyn-dim --batch 3 --dyn-input-dim @data "[{min:1, max:4}, 3, 224, 224]"

bin/driver compile /codes/onnx_models/resnet50-v1-7/resnet50-v1-7.onnx --split-single-dyn-dim --default-dyn-dim "{min:1, max:10}" --output resnet50_batch1-10.mxr

bin/driver perf resnet50_batch1-10.mxr --batch 4

Automatically fuse multiple reductions and pointwise operations.