为什么await async这么慢?

我终于得到了VS2012，并得到了一个简单的演示，并开始工作，以检查async和await的潜在性能提升，但令我沮丧的是它更慢!我可能做错了什么，但也许你能帮我一把。(我还添加了一个简单的线程解决方案，运行速度比预期的要快)

我的代码使用一个类来求和数组，基于系统上的核心数量(-1)我的有4个核心，所以我看到线程的速度提高了2倍(2.5个线程)，但同样的事情放慢了2倍，但使用async/await。

代码:(注意，您需要将引用添加到System.Management以使核心检测器工作)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Management;
using System.Diagnostics;
namespace AsyncSum
{
    class Program
    {
        static string Results = "";
        static void Main(string[] args)
        {
            Task t = Run();
            t.Wait();
            Console.WriteLine(Results);
            Console.ReadKey();
        }
        static async Task Run()
        {
            Random random = new Random();
            int[] huge = new int[1000000];
            for (int i = 0; i < huge.Length; i++)
            {
                huge[i] = random.Next(2);
            }
            ArraySum summer = new ArraySum(huge);
            Stopwatch sw = new Stopwatch();
            sw.Restart();
            long tSum = summer.Sum();
            for (int i = 0; i < 100; i++)
            {
                tSum = summer.Sum();
            }
            long tticks = sw.ElapsedTicks / 100;
            long aSum = await summer.SumAsync();
            sw.Restart();
            for (int i = 0; i < 100; i++)
            {
                aSum = await summer.SumAsync();
            }
            long aticks = sw.ElapsedTicks / 100;
            long dSum = summer.SumThreaded();
            sw.Restart();
            for (int i = 0; i < 100; i++)
            {
                dSum = summer.SumThreaded();
            }
            long dticks = sw.ElapsedTicks / 100;

            long pSum = summer.SumParallel();
            sw.Restart();
            for (int i = 0; i < 100; i++)
            {
                pSum = summer.SumParallel();
            }
            long pticks = sw.ElapsedTicks / 100;
            Program.Results += String.Format("Regular Sum: {0} in {1} ticks'n", tSum, tticks);
            Program.Results += String.Format("Async Sum: {0} in {1} ticks'n", aSum, aticks);
            Program.Results += String.Format("Threaded Sum: {0} in {1} ticks'n", dSum, dticks);
            Program.Results += String.Format("Parallel Sum: {0} in {1} ticks'n", pSum, pticks);
        }
    }
    class ArraySum
    {
        int[] Data;
        int ChunkSize = 1000;
        int cores = 1;

        public ArraySum(int[] data)
        {
            Data = data;
            cores = 0;
            foreach (var item in new System.Management.ManagementObjectSearcher("Select * from Win32_Processor").Get())
            {
                cores += int.Parse(item["NumberOfCores"].ToString());
            }
            cores--;
            if (cores < 1) cores = 1;
            ChunkSize = Data.Length / cores + 1;
        }
        public long Sum()
        {
            long sum = 0;
            for (int i = 0; i < Data.Length; i++)
            {
                sum += Data[i];
            }
            return sum;
        }
        public async Task<long> SumAsync()
        {
            Task<long>[] psums = new Task<long>[cores];
            for (int i = 0; i < psums.Length; i++)
            {
                int start = i * ChunkSize;
                int end = start + ChunkSize;
                psums[i] = Task.Run<long>(() =>
                {
                    long asum = 0;
                    for (int a = start; a < end && a < Data.Length; a++)
                    {
                        asum += Data[a];
                    }
                    return asum;
                });
            }
            long sum = 0;
            for (int i = 0; i < psums.Length; i++)
            {
                sum += await psums[i];
            }
            return sum;
        }
        public long SumThreaded()
        {
            long sum = 0;
            Thread[] threads = new Thread[cores];
            long[] buckets = new long[cores];
            for (int i = 0; i < cores; i++)
            {
                int start = i * ChunkSize;
                int end = start + ChunkSize;
                int bucket = i;
                threads[i] = new Thread(new ThreadStart(() =>
                {
                    long asum = 0;
                    for (int a = start; a < end && a < Data.Length; a++)
                    {
                        asum += Data[a];
                    }
                    buckets[bucket] = asum;
                }));
                threads[i].Start();
            }
            for (int i = 0; i < cores; i++)
            {
                threads[i].Join();
                sum += buckets[i];
            }
            return sum;
        }
        public long SumParallel()
        {
            long sum = 0;
            long[] buckets = new long[cores];
            ParallelLoopResult lr = Parallel.For(0, cores, new Action<int>((i) =>
            {
                int start = i * ChunkSize;
                int end = start + ChunkSize;
                int bucket = i;
                long asum = 0;
                for (int a = start; a < end && a < Data.Length; a++)
                {
                    asum += Data[a];
                }
                buckets[bucket] = asum;
            }));
            for (int i = 0; i < cores; i++)
            {
                sum += buckets[i];
            }
            return sum;
        }
    }
}

任何想法吗?我做async/await错误吗?我很乐意尝试任何建议。