[PATCH v3 1/2] dma-fence: Add unwrap mode enum and macro for in-place deduplication

[Christian König]

On 4/29/25 17:24, Arvind Yadav wrote:
> Introduce a new `enum dma_fence_unwrap_mode` to support multiple modes
> of fence unwrapping and merging behavior. This lays the groundwork for
> more flexible and efficient fence operations.
> 
> Add a new macro `dma_fence_unwrap_shrink_array()` to allow callers to
> unwrap, deduplicate, and sort dma_fence arrays in-place, avoiding
> additional memory allocations. This mode filters out already signaled
> fences and keeps only the latest fence per context.
> 
> To support this, refactor `__dma_fence_unwrap_merge()` to handle both
> merge and shrink modes through the new `dma_fence_unwrap_mode` parameter.
> The sorting and deduplication logic is extracted into a new helper function
> `dma_fence_unwrap_dedup_sort()`.
> 
> These changes allow clients to efficiently compact arrays of fences with
> minimal overhead, improving memory usage and performance in common
> scenarios like command submission or dependency tracking.
> 
> v2: - Export this code from dma-fence-unwrap.c(by Christian).
> v3: - To split this in a dma_buf patch and amd userq patch(by Sunil).
>     - No need to add a new function just re-use existing(by Christian).
> 
> Cc: Alex Deucher <alexander.deucher at amd.com>
> Cc: Christian Koenig <christian.koenig at amd.com>
> Cc: Sunil Khatri <sunil.khatri at amd.com>
> Cc: Arunpravin Paneer Selvam <Arunpravin.PaneerSelvam at amd.com>
> Signed-off-by: Arvind Yadav <Arvind.Yadav at amd.com>
> ---
>  drivers/dma-buf/dma-fence-unwrap.c | 54 +++++++++++++++++++++---------
>  include/linux/dma-fence-unwrap.h   | 44 ++++++++++++++++++++++--
>  2 files changed, 81 insertions(+), 17 deletions(-)
> 
> diff --git a/drivers/dma-buf/dma-fence-unwrap.c b/drivers/dma-buf/dma-fence-unwrap.c
> index 2a059ac0ed27..f389c37a0eb5 100644
> --- a/drivers/dma-buf/dma-fence-unwrap.c
> +++ b/drivers/dma-buf/dma-fence-unwrap.c
> @@ -79,15 +79,51 @@ static int fence_cmp(const void *_a, const void *_b)
>  	return 0;
>  }
>  
> +static void dma_fence_unwrap_dedup_sort(struct dma_fence **array,
> +					unsigned int *count)

Just call that dma_fence_dedup_array() (e.g. without the unwrap).

> +{
> +	int i, j;
> +
> +	sort(array, *count, sizeof(*array), fence_cmp, NULL);
> +
> +	/*
> +	 * Only keep the most recent fence for each context.
> +	 */
> +	j = 0;
> +	for (i = 1; i < *count; i++) {
> +		if (array[i]->context == array[j]->context)
> +			dma_fence_put(array[i]);
> +		else
> +			array[++j] = array[i];
> +	}
> +
> +	*count = ++j;
> +}

Instead of making count a pointer just return the resulting count.

> +
>  /* Implementation for the dma_fence_merge() marco, don't use directly */
>  struct dma_fence *__dma_fence_unwrap_merge(unsigned int num_fences,
>  					   struct dma_fence **fences,
> -					   struct dma_fence_unwrap *iter)
> +					   struct dma_fence_unwrap *iter,
> +					   enum dma_fence_unwrap_mode mode,
> +					   unsigned int *out_count)
>  {
>  	struct dma_fence *tmp, *unsignaled = NULL, **array;
>  	struct dma_fence_array *result;
>  	ktime_t timestamp;
> -	int i, j, count;
> +	int i, count;
> +
> +	if (mode == DMA_FENCE_UNWRAP_ARRAY) {
> +		array = fences;
> +		count = num_fences;
> +
> +		if (count > 1)
> +			dma_fence_unwrap_dedup_sort(array, &count);
> +
> +		if (out_count)
> +			*out_count = count;
> +
> +		return NULL;
> +	}


Completely drop that. Just export the dma_fence_dedup_array() function and use that directly.

Regards,
Christian.

>  
>  	count = 0;
>  	timestamp = ns_to_ktime(0);
> @@ -141,19 +177,7 @@ struct dma_fence *__dma_fence_unwrap_merge(unsigned int num_fences,
>  	if (count == 0 || count == 1)
>  		goto return_fastpath;
>  
> -	sort(array, count, sizeof(*array), fence_cmp, NULL);
> -
> -	/*
> -	 * Only keep the most recent fence for each context.
> -	 */
> -	j = 0;
> -	for (i = 1; i < count; i++) {
> -		if (array[i]->context == array[j]->context)
> -			dma_fence_put(array[i]);
> -		else
> -			array[++j] = array[i];
> -	}
> -	count = ++j;
> +	dma_fence_unwrap_dedup_sort(array, &count);
>  
>  	if (count > 1) {
>  		result = dma_fence_array_create(count, array,
> diff --git a/include/linux/dma-fence-unwrap.h b/include/linux/dma-fence-unwrap.h
> index 66b1e56fbb81..b5683b024548 100644
> --- a/include/linux/dma-fence-unwrap.h
> +++ b/include/linux/dma-fence-unwrap.h
> @@ -10,6 +10,18 @@
>  
>  struct dma_fence;
>  
> +/**
> + * enum dma_fence_unwrap_mode - Mode of operation for fence unwrap and merge
> + * @DMA_FENCE_UNWRAP_MERGE: Merge all unsignaled fences into a new dma_fence object.
> + *                          Returns a single merged fence or stub.
> + * @DMA_FENCE_UNWRAP_ARRAY: Deduplicate and sort fences in-place.
> + *                          Returns nothing, but updates the input array and count.
> + */
> +enum dma_fence_unwrap_mode {
> +	DMA_FENCE_UNWRAP_MERGE,  /* Return a single merged dma_fence or NULL on error */
> +	DMA_FENCE_UNWRAP_ARRAY,  /* Return deduplicated, sorted in-place array */
> +};
> +
>  /**
>   * struct dma_fence_unwrap - cursor into the container structure
>   *
> @@ -50,7 +62,9 @@ struct dma_fence *dma_fence_unwrap_next(struct dma_fence_unwrap *cursor);
>  
>  struct dma_fence *__dma_fence_unwrap_merge(unsigned int num_fences,
>  					   struct dma_fence **fences,
> -					   struct dma_fence_unwrap *cursors);
> +					   struct dma_fence_unwrap *cursors,
> +					   enum dma_fence_unwrap_mode mode,
> +					   unsigned int *out_count);
>  
>  /**
>   * dma_fence_unwrap_merge - unwrap and merge fences
> @@ -58,6 +72,9 @@ struct dma_fence *__dma_fence_unwrap_merge(unsigned int num_fences,
>   * All fences given as parameters are unwrapped and merged back together as flat
>   * dma_fence_array. Useful if multiple containers need to be merged together.
>   *
> + * Internally uses the DMA_FENCE_UNWRAP_MERGE mode to return a single merged
> + * dma_fence (or a stub if all fences are signaled).
> + *
>   * Implemented as a macro to allocate the necessary arrays on the stack and
>   * account the stack frame size to the caller.
>   *
> @@ -69,7 +86,30 @@ struct dma_fence *__dma_fence_unwrap_merge(unsigned int num_fences,
>  		struct dma_fence *__f[] = { __VA_ARGS__ };		\
>  		struct dma_fence_unwrap __c[ARRAY_SIZE(__f)];		\
>  									\
> -		__dma_fence_unwrap_merge(ARRAY_SIZE(__f), __f, __c);	\
> +		__dma_fence_unwrap_merge(ARRAY_SIZE(__f), __f, __c,	\
> +					 DMA_FENCE_UNWRAP_MERGE, NULL);	\
> +	})
> +
> +/**
> + * dma_fence_unwrap_shrink_array - Deduplicate and sort an array of fences in-place
> + * @ _num_fences: Number of input fences
> + * @ _fences:     Array of dma_fence pointers to be deduplicated and sorted
> + * @ _out_fences: Output variable updated with the number of fences after deduplication
> + *
> + * This macro unwraps each fence (handling dma_fence_array if needed),
> + * filters out signaled fences, sorts the remaining ones by context and
> + * timestamp, and removes duplicates (keeping only the most recent fence per context).
> + *
> + * Internally uses the DMA_FENCE_UNWRAP_ARRAY mode to perform in-place filtering and
> + * sorting.
> + *
> + * The result is stored back in the input array (_fences) and the final count
> + * is written to @_out_fences. No memory allocation is performed.
> + */
> +#define dma_fence_unwrap_shrink_array(_num_fences, _fences, _out_fences)	\
> +	({									\
> +		__dma_fence_unwrap_merge((_num_fences), (_fences), NULL,	\
> +					 DMA_FENCE_UNWRAP_ARRAY, &_out_fences);	\
>  	})
>  
>  #endif