C# og dual core processor

ja - mindst 2 tråde - 4 er formentligt bedre

Havde det lidt på fornemmelsen, men tak for det hurtige svar. Jeg tager det for gode varer, når det kommer fra dig Arne.

Smid et svar, så skal jeg bidrage til din point høst

ok

prøv og se om det her program kan udnytte dine 2 core:

using System;
using System.Threading;

namespace E
{
  public class ThreadSort
  {
      private const int N = 10000000;
      private const int REP = 3;
      public static void Main(String[] args)
      {
          Random rng = new Random(1234567);
          int[] ia = new int[N];
          for (int i = 0; i < ia.Length; i++)
          {
            ia[i] = rng.Next();
          }
          for (int j = 0; j < REP; j++)
          {
            int[] ia1 = (int[]) ia.Clone();
            long t1 = DateTime.Now.Ticks;
            QSInt(ia1);
            long t2 = DateTime.Now.Ticks;
            Console.WriteLine("Single threaded qsort : " + (t2 - t1));
            //Console.WriteLine(ia1[0] + " " + ia1[N / 2] + " " + ia1[N - 1]);
            int[] ia2 = (int[]) ia.Clone();
            long t3 = DateTime.Now.Ticks;
            TQSInt(ia2, 1);
            long t4 = DateTime.Now.Ticks;
            Console.WriteLine("Double threaded qsort : " + (t4 - t3));
            //Console.WriteLine(ia2[0] + " " + ia2[N / 2] + " " + ia2[N - 1]);
            int[] ia3 = (int[]) ia.Clone();
            long t5 = DateTime.Now.Ticks;
            TQSInt(ia3, 2);
            long t6 = DateTime.Now.Ticks;
            Console.WriteLine("Quadrouple threaded qsort : " + (t6 - t5));
            //Console.WriteLine(ia2[0] + " " + ia2[N / 2] + " " + ia2[N - 1]);
          }
      }
      public static void QSInt(int[] ia)
      {
          QSInt_help(0, ia.Length - 1, ia);
          return;
      }
      public static void QSInt_help(int n1, int n2, int[] ia)
      {
          int tmp;
          int l = n1;
          int r = n2;
          int pivot = ia[(n1 + n2) / 2];
          do
          {
            while (ia[l] < pivot)
                l++;
            while (ia[r] > pivot)
                r--;
            if (l <= r)
            {
                tmp = ia[l];
                ia[l] = ia[r];
                ia[r] = tmp;
                l++;
                r--;
            }
          }
          while (l <= r);
          if (n1 < r)
            QSInt_help(n1, r, ia);
          if (l < n2)
            QSInt_help(l, n2, ia);
          return;
      }
      public static void TQSInt(int[] ia, int tdepth)
      {
          TQSInt_help(0, ia.Length - 1, ia, 0, tdepth);
          return;
      }
      public static void TQSInt_help(int n1, int n2, int[] ia, int depth, int tdepth)
      {
          int tmp;
          int l = n1;
          int r = n2;
          int pivot = ia[(n1 + n2) / 2];
          do
          {
            while (ia[l] < pivot)
                l++;
            while (ia[r] > pivot)
                r--;
            if (l <= r) {
                tmp = ia[l];
                ia[l] = ia[r];
                ia[r] = tmp;
                l++;
                r--;
            }
          }
          while (l <= r);
          if (depth >= tdepth)
          {
            if (n1 < r)
                TQSInt_help(n1, r, ia, depth + 1, tdepth);
            if (l < n2)
                TQSInt_help(l, n2, ia, depth + 1, tdepth);
          }
          else
          {
            Thread h1 = new Thread(new ThreadStart((new ThreadSortHelp(n1, r, ia, depth + 1, tdepth)).Run));
            Thread h2 = new Thread(new ThreadStart((new ThreadSortHelp(l, n2, ia, depth + 1, tdepth)).Run));
            h1.Start();
            h2.Start();
            h1.Join();
            h2.Join();
          }
          return;
      }
    }
   
    public class ThreadSortHelp
    {
      private int n1;
      private int n2;
      private int[] ia;
      private int depth;
      private int tdepth;
      public ThreadSortHelp(int n1, int n2, int[] ia, int depth, int tdepth)
      {
          this.n1 = n1;
          this.n2 = n2;
          this.ia = ia;
          this.depth = depth;
          this.tdepth = tdepth;
      }
      public void Run()
      {
          ThreadSort.TQSInt_help(n1, n2, ia, depth, tdepth);
      }
    }
}

Det svinger naturligvis en del, men det ser faktisk ud til,
at det du kalder double og quadrouple sort kan få processoren over 50 %.

Single threaded qsort : 29146381
Double threaded qsort : 20106327
Quadrouple threaded qsort : 20262190
Single threaded qsort : 28990518
Double threaded qsort : 19794601
Quadrouple threaded qsort : 20418053
Single threaded qsort : 28990518
Double threaded qsort : 19638738
Quadrouple threaded qsort : 20106327

Det er naturligvis interessant, men jeg er ikke helt med på hvordan jeg kan udnytte princippet i mit eget program.

Så vidt jeg kan se starter du jo 2 threads i koden og jeg er ikke helt sikker på, at jeg så nemt vil kunne parallelisere mit program.

Men det var måske mere et hint til hvor mange threads jeg skulle bruge til at udnytte Intel monsteret.

Allan

1000 kroners spørgsmålet... Hvorfer er det så vigtigt at det skal belaste begge 100% eller hvad er det du vil?...

Der må være nogle specifikke årsager til du gerne vil dette, de årsager kunne måske være til stor hjælp for os når vi skal hjælpe...

Dit program tygger på en stor opgave?
Dit program tygger på flere store opgaver?
eller andre grunde?...

det var bare et simpelt eksempel som kunne udnytte flere tråde - ikke andet

du må selv parallelisere din kode, hvis du skal udnytte flere kerner