Spike Your CPU’s Processor in .Net

using System.Threading;

using System.Runtime.InteropServices;

// Target a specific processor for the thread to run on

public class ThreadProcessor

{

    [DllImport("kernel32.dll")]

    static extern IntPtr GetCurrentThread();

    [DllImport("kernel32.dll")]

    static extern IntPtr SetThreadAffinityMask(IntPtr hThread, IntPtr dwThreadAffinityMask);

    public static void Usage()

    {

        int cpu = 0;

        ThreadProcessor tp = new ThreadProcessor();

        Console.WriteLine("Spike CPU 1");

        tp.SpikeCPU(cpu);

        if (tp._ex != null)

        {

            Console.WriteLine(tp._ex.Message);

        }

        else

        {

            if (Environment.ProcessorCount > 1)

            {

                while (++cpu < Environment.ProcessorCount)

                {

                    Thread.Sleep(1000);

                    Console.WriteLine("Spike CPU " + (cpu + 1).ToString());

                    tp.SpikeCPU(cpu);

                    if (tp._ex != null)

                    {

                        Console.WriteLine(tp._ex.Message);

                        break;

                    }

                }

            }

            else // Either a single CPU or hyperthreading not enabled in the OS or the BIOS.

            {

                Console.WriteLine("This PC does not have two processors available.");

            }

        }

    }

    private Thread _worker;

    private const int PiSignificantDigits = 750; // Adjust to your processor

    // Spike the CPU and waith for it to finish

    public void SpikeCPU(int targetCPU)

    {

        // Create a worker thread for the work.

        _worker = new Thread(DoBusyWork);

        // Background is set so not to not prevent the

        // mainprocess from terminating if someone closes it.

        _worker.IsBackground = true;

        _worker.Start((object)targetCPU);

        _worker.Join(); // Wait for it to be done.

    }

    public void DoBusyWork(object target)

    {

        try

        {

            int processor = (int)target;

            Thread tr = Thread.CurrentThread;

            if (Environment.ProcessorCount > 1)

            {

                SetThreadAffinityMask(GetCurrentThread(),

                    new IntPtr(1 << processor));

            }

            CalculatePI.Process(PiSignificantDigits);

        }

        catch (Exception ex)

        {

            _ex = ex;

        }

    }

    public Exception _ex = null;

}

public class CalculatePI
{
    /*
     * Computation of the n'th decimal digit of \pi with very little memory.
     * Written by Fabrice Bellard on January 8, 1997.
     *
     * We use a slightly modified version of the method described by Simon
     * Plouffe in "On the Computation of the n'th decimal digit of various
     * transcendental numbers" (November 1996). We have modified the algorithm
     * to get a running time of O(n^2) instead of O(n^3log(n)^3).
     *
     * This program uses mostly integer arithmetic. It may be slow on some
     * hardwares where integer multiplications and divisons must be done
     * by software. We have supposed that 'int' has a size of 32 bits. If
     * your compiler supports 'long long' integers of 64 bits, you may use
     * the integer version of 'mul_mod' (see HAS_LONG_LONG). 
     */
 
    // Call this static to use.
    public static string Process(int digits)
    {
        StringBuilder result = new StringBuilder();
 
        result.Append("3.");
 
        DateTime StartTime = DateTime.Now;
 
        if (digits > 0)
        {
 
            for (int i = 0; i < digits; i += 9)
            {
                String ds = CalculatePiDigits(i + 1);
                int digitCount = Math.Min(digits - i, 9);
 
                if (ds.Length < 9)
                    ds = string.Format("{0:D9}", int.Parse(ds));
 
                result.Append(ds.Substring(0, digitCount));
            }
        }
 
        return result.ToString();
    }
 
 
    private static int mul_mod(int a, int b, int m)
    {
        return (int)(((long)a * (long)b) % m);
    }
 
    /* return the inverse of x mod y */
    private static int inv_mod(int x, int y)
    {
        int q, u, v, a, c, t;
 
        u = x;
        v = y;
        c = 1;
        a = 0;
 
        do
        {
            q = v / u;
 
            t = c;
            c = a - q * c;
            a = t;
 
            t = u;
            u = v - q * u;
            v = t;
        } while (u != 0);
 
        a = a % y;
 
        if (a < 0)
        {
            a = y + a;
        }
 
        return a;
    }
 
    /* return (a^b) mod m */
    private static int pow_mod(int a, int b, int m)
    {
        int r, aa;
 
        r = 1;
        aa = a;
 
        while (true)
        {
            if ((b & 1) != 0)
            {
                r = mul_mod(r, aa, m);
            }
 
            b = b >> 1;
 
            if (b == 0)
            {
                break;
            }
 
            aa = mul_mod(aa, aa, m);
        }
 
        return r;
    }
 
    /* return true if n is prime */
    private static bool is_prime(int n)
    {
        if ((n % 2) == 0)
        {
            return false;
        }
 
        int r = (int)Math.Sqrt(n);
 
        for (int i = 3; i <= r; i += 2)
        {
            if ((n % i) == 0)
            {
                return false;
            }
        }
 
        return true;
    }
 
    /* return the prime number immediatly after n */
    private static int next_prime(int n)
    {
        do
        {
            n++;
        } while (!is_prime(n));
 
        return n;
    }
 
    private static String CalculatePiDigits(int n)
    {
        int av, vmax, num, den, s, t;
 
        int N = (int)((n + 20) * Math.Log(10) / Math.Log(2));
 
        double sum = 0;
 
        for (int a = 3; a <= (2 * N); a = next_prime(a))
        {
            vmax = (int)(Math.Log(2 * N) / Math.Log(a));
 
            av = 1;
 
            for (int i = 0; i < vmax; i++)
            {
                av = av * a;
            }
 
            s = 0;
            num = 1;
            den = 1;
            int v = 0;
            int kq = 1;
            int kq2 = 1;
 
            for (int k = 1; k <= N; k++)
            {
 
                t = k;
 
                if (kq >= a)
                {
                    do
                    {
                        t = t / a;
                        v--;
                    } while ((t % a) == 0);
 
                    kq = 0;
                }
                kq++;
                num = mul_mod(num, t, av);
 
                t = 2 * k - 1;
 
                if (kq2 >= a)
                {
                    if (kq2 == a)
                    {
                        do
                        {
                            t = t / a;
                            v++;
                        } while ((t % a) == 0);
                    }
                    kq2 -= a;
                }
                den = mul_mod(den, t, av);
                kq2 += 2;
 
                if (v > 0)
                {
                    t = inv_mod(den, av);
                    t = mul_mod(t, num, av);
                    t = mul_mod(t, k, av);
 
                    for (int i = v; i < vmax; i++)
                    {
                        t = mul_mod(t, a, av);
                    }
 
                    s += t;
 
                    if (s >= av)
                    {
                        s -= av;
                    }
                }
 
            }
 
            t = pow_mod(10, n - 1, av);
            s = mul_mod(s, t, av);
            sum = (sum + (double)s / (double)av) % 1.0;
        }
 
        int Result = (int)(sum * 1e9);
 
        String StringResult = String.Format("{0:D9}", Result);
 
        return StringResult;
    }
 
    // Put a space between every group of 10 digits.
 
    private static String breakDigitsIntoGroupsOf10(String digits)
    {
        String result = "";
 
        while (digits.Length > 10)
        {
            result += digits.Substring(0, 10) + " ";
            digits = digits.Substring(10, digits.Length - 10);
        }
 
        result += digits;
 
        return result;
    }
 
}