runtime: AsParallel causes extremely slow 'WorkloadJitting' performance in BenchmarkDotNet benchmark

Description

I managed to write a benchmark that makes the WorkloadJitting phase of BenchmarkDotNet perform extremely slowly.

For a count of 4:

WorkloadJitting  1: 1 op, 11779303800.00 ns, 11.7793 s/op

For a count of 8:

WorkloadJitting  1: 1 op, 29785615800.00 ns, 29.7856 s/op

Those are seconds!

The actual benchmark code runs fast after the WorkloadJitting phase finally completes.

I have included the minimal repro program in the Reproduction Steps section.

Note that removing the call to AsParallel() makes everything fast again.

Reproduction Steps

using System;
using System.Collections.Generic;
using System.Linq;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace Test
{
    public class PerfTest
    {
        [Params(4, 8)]
        public int PredicateCount { get; set; }

        [Benchmark]
        public void Test()
        {
            IEnumerable<int> rows = new int[] { 1234 };
            var predicates = new Func<int, bool>[PredicateCount];

            for (int i = 0; i < PredicateCount; i++)
            {
                predicates[i] = x => true;
            }

            foreach (var predicate in predicates)
            {
                rows = rows.AsParallel().Where(predicate);
            }

            var x = rows.ToList();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            BenchmarkRunner.Run(typeof(Program).Assembly);
        }
    }
}

Expected behavior

Should be fast.

Actual behavior

Incredibly slow.

Regression?

No response

Known Workarounds

No response

Configuration

No response

Other information

No response