22. september 2007 - 17:33
Der er
7 kommentarer og
1 løsning
udnyttelse af tråde på den multi processor maskiner
Lad mig starte med at sige at min viden om hardware er minimal, og at dette spørgsmål nok er et mix mellem generel programmering,hardware og c#.
Såfremt man afvikler sin C# applikation på en multi processor og man spinder tråde ud, kan/vil disse så kunne afvikles på flere processorer så man der med kan opnå bedre performance for sin app? eller kan den enkelte proces ikke spænde over flere processorer?
Jeg har en mistanke om at det selvfølgelig afhænger af både OS og hardware, men lad mig høre nogle eksperter
22. september 2007 - 18:07
#1
En multitrådet process kan udnytte flere processorer hvis styre systemet understøtter det.
Og Windows NT/2000/XP/2003/Vista/2008 understøtter det.
Ligesom Linux, MacOS X, diverse Unix etc.etc..
20. november 2009 - 14:52
#7
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);
}
}
}
