parallelizing async calls

[pianoman4873]

Hello,
Assuming funcAsync is some IO bound operations -
which of the following implementations of BatchExecuteAsync would be preferrable for better throughput / efficiency etc. ?

Thanks

public static async Task BatchedExecuteAsync(this List items, Func<TItem, Task> funcAsync, int amountOfParallelism)
{

var tasks = new List<Task>(amountOfParallelism);
int index = 0;
for (var i = 0; i < amountOfParallelism; i++)
{
    tasks.Add(Task.Run(async () =>
    {
        while (true)
        {
            TItem item;
            lock (tasks)
            {
                if (index >= items.Count)
                {
                    break;
                }

                item = items[index];
                index++;
            }

            await funcAsync(item);
        }
    }));
}

await Task.WhenAll(tasks);
}

public static async Task BatchedExecuteAsync(this IEnumerable items, Func<TItem,Task> funcAsync, int amountOfParallelism)
{

        var tasks = new List<Task>(amountOfParallelism);
        foreach (var item in items)
        {
            tasks.Add(funcAsync ( item));
            if (tasks.Count == amountOfParallelism)
            {
                await Task.WhenAll(tasks);
                tasks.Clear();
            }
        }
        if (tasks.Count > 0)
        {
            await Task.WhenAll(tasks);
            
        }
    }

[Clockwork-Muse]

To an extent, neither.

This is in effect creating a task scheduler without extending the actual abstract TaskScheduler. Limited-count implementations already exist, so you'd be best advised to use one of those, if possible.

After that, the primary consideration is going to be how much work is occurring for each item. If it's relatively long, generally queueing a task per each would be preferrable for cleanliness reasons. If it's really short, then potentially consider batching the individual elements (but recall you'll lose information about individual elements in the batch).

[huoyaoyuan]

Issues in your implementations:

• Avoid taking a lock in tasks. Consider to use more efficient solutions like rate limiting.
• Precisely-allocated list is definitely worse than array.
• Awaiting all operations in a batch before next batch is wasting. The effective degree of parallelism will be much lower.
• LINQ is quite effective comparing with overhead of asynchronous calls

A hypothetic solution can be:

foreach (var chunk in items.Chunk(amountOfParallelism))
{
    await Task.WhenAll(chunk.Select(item => funcAsync(item)));
}

Preserves your (non-best) behavior and is much simpler.