Ergebnis 1 bis 11 von 11

Thema: C# Programm wird immer langsamer

  1. #1
    Temporär Suspendiert :D Avatar von KcDaRookie
    Registriert seit
    Jul 2013
    Beiträge
    265

    C# Programm wird immer langsamer

    Tachchen Zusammen,

    Ich hab einen txt2pdf Converter in C# der txt-Dateien aus dem input-Ordner als PDF im output-Ordner speichert.
    Dazu benutze ich die PdfSharp Library, und das klappt auch ganz gut, nur wird der Converter immer langsamer.
    Bei weniger als 1000 Dateien merkt man das nicht so, ich müsste aber bisschen über 100.000 txt-Dateien umwandeln.

    Nur weiß ich nicht wo genau das Problem liegt. Ich glaube, der Arbeitsspeicher wird immer weiter zugemüllt und hab da den StreamReader im Verdacht, aber den close und dispose ich nach jeder Datei.
    Habt ihr noch eine Idee, was man optimieren könnte?

    Spoiler: 

    Code (C#):
    1. using System;
    2. using System.IO;
    3. using System.Reflection;
    4. using PdfSharp.Drawing;
    5. using PdfSharp.Pdf;
    6.  
    7. using System.Windows.Forms;
    8.  
    9. namespace WindowsFormsApplication4
    10. {
    11.     public partial class Form1 : Form
    12.     {
    13.         public static int filecount;
    14.         public Form1()
    15.         {
    16.             //eingebettete pdfsharp.dll wird hier eingelesen
    17.             AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
    18.             {
    19.                 string resourceName = new AssemblyName(args.Name).Name + ".dll";
    20.                 string resource = Array.Find(this.GetType().Assembly.GetManifestResourceNames(), element => element.EndsWith(resourceName));
    21.  
    22.                 using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resource))
    23.                 {
    24.                     Byte[] assemblyData = new Byte[stream.Length];
    25.                     stream.Read(assemblyData, 0, assemblyData.Length);
    26.                     return Assembly.Load(assemblyData);
    27.                 }
    28.             };
    29.             InitializeComponent();
    30.             //überprüfen ob der input ordner existiert und dateien enthält
    31.             invoiceamount();
    32.         }
    33.  
    34.         private void invoiceamount()
    35.         {
    36.             if (!Directory.Exists("input"))
    37.             {
    38.                 label1.Text = "No input folder found.";
    39.                 button1.Enabled = false;
    40.                 button1.Refresh();
    41.             }
    42.             else
    43.             {
    44.                 filecount = Directory.GetFiles("input").Length;
    45.                 if (filecount < 1)
    46.                 {
    47.                     label1.Text = "No files in input folder.";
    48.                     button1.Enabled = false;
    49.                     button1.Refresh();
    50.                 }
    51.                 else
    52.                 {
    53.                     label1.Text = "File count: " + filecount;
    54.                 }
    55.             }
    56.         }
    57.  
    58.         private void button1_Click(object sender, EventArgs e)
    59.         {
    60.             startconvert();
    61.         }
    62.  
    63.         private void startconvert()
    64.         {
    65.             if (!Directory.Exists("output"))
    66.             {
    67.                 Directory.CreateDirectory("output");
    68.             }
    69.             int processed = 0;
    70.             string[] fileEntries = Directory.GetFiles("input");
    71.             foreach (string fileName in fileEntries)
    72.             {
    73.                 //files an converter weiterreichen
    74.                 convert(fileName);
    75.                 processed++;
    76.                 if (processed % 10 == 0)
    77.                 {
    78.                     label2.Text = "Processed: " + processed.ToString();
    79.                     label2.Refresh();
    80.                 }
    81.             }
    82.         }
    83.  
    84.         private void convert(string input)
    85.         {
    86.             {
    87.                 //hier wird mit dem SR die Textdatei durchgegangen und bei einem form feed eine neue PDF Seite gestartet
    88.                 //Ich hab nur den Font und das Seitenlayout etwas angepasst, der Originalcode kommt von hier http://forum.pdfsharp.de/viewtopic.php?f=8&t=3072
    89.  
    90.                 const double LINE_SPACING = 6.8;
    91.                 const double FONT_SIZE = 7.2;
    92.                 const int MAX_LINES = 112;
    93.                 StreamReader sr = new StreamReader(input, System.Text.Encoding.Default);
    94.                 PdfDocument document = new PdfDocument();
    95.                 XFont font = new XFont("Courier New", FONT_SIZE, XFontStyle.Regular, null);
    96.                 string textAfterFormFeed = "";
    97.                 while (sr.Peek() >= 0)
    98.                 {
    99.                     PdfPage page = document.AddPage();
    100.                     XGraphics gfx = XGraphics.FromPdfPage(page);
    101.                     bool formFeed = false;
    102.                     string buffer = "";
    103.                     double pos = 30;
    104.                     int lines = 0;
    105.                     if (textAfterFormFeed != "")
    106.                     {
    107.                         gfx.DrawString(textAfterFormFeed, font, XBrushes.Black, new XRect(12, pos, page.Width, page.Height), XStringFormats.TopLeft);
    108.                         pos = pos + LINE_SPACING;
    109.                         lines++;
    110.                         textAfterFormFeed = "";
    111.                     }
    112.                     while (sr.Peek() >= 0 && !formFeed)
    113.                     {
    114.                         buffer = sr.ReadLine();
    115.                         if (buffer.IndexOf("\x0c") >= 0)
    116.                         {
    117.                             formFeed = true;
    118.                             if (buffer.IndexOf("\x0c") + 1 != buffer.Length)
    119.                                 textAfterFormFeed = buffer.Substring(buffer.IndexOf("\x0c") + 1, buffer.Length - buffer.IndexOf("\x0c") - 1);
    120.                             if (buffer.IndexOf("\x0c") > 0)
    121.                                 gfx.DrawString(buffer.Substring(0, buffer.IndexOf("\x0c")), font, XBrushes.Black, new XRect(12, pos, page.Width, page.Height), XStringFormats.TopLeft);
    122.                         }
    123.                         else
    124.                             gfx.DrawString(buffer, font, XBrushes.Black, new XRect(12, pos, page.Width, page.Height), XStringFormats.TopLeft);
    125.                         pos = pos + LINE_SPACING;
    126.                         lines++;
    127.                         if (lines > MAX_LINES)
    128.                             formFeed = true;
    129.                     }
    130.                 }
    131.                 sr.Close();
    132.                 sr.Dispose();
    133.                 string output = input.Replace("input\\", "");
    134.                 output = output.Replace(".txt", "");
    135.                 document.Save("output\\" + output + ".pdf");
    136.                 document.Close();
    137.             }
    138.         }
    139.     }
    140.  
    141.  
    142. }
    143.  
    Was Microsoft außer Windows und Office noch zu bieten hat.
    Die Kunst das letzte Wort zu haben.
    Die Wahrscheinlichkeit das keine Antwort mehr nach meinem Post kommt liegt bei 80% ^^

    R.I.P. Gulli *6. November 1998 - † 01. Juli 2013

  2. #2
    Team ModMii Avatar von Timon3
    Registriert seit
    Jul 2013
    Beiträge
    497

    Re: C# Programm wird immer langsamer

    Mir fällt beim Drübergucken nichts besonderes auf, außer, dass du jedes Mal die Font neu reinlädst - die kannst du doch auch nur ein mal laden und immer wieder verwenden.

    Ansonsten solltest du mal mit einem Memory Profiler das Programm Debuggen. Der sollte dir anzeigen, wo genau der Speicher verbraucht wird. Bist du dir denn sicher, dass ein Memory Leak vorliegt? Das kannst du ja einfach mal über einen Debugger (oder den Task-Manager) verfolgen.

  3. #3
    Temporär Suspendiert :D

    (Threadstarter)

    Avatar von KcDaRookie
    Registriert seit
    Jul 2013
    Beiträge
    265

    Re: C# Programm wird immer langsamer

    Hmm seltsam, gestern ging die Process Memory Kurve bei Visual Studio hoch bis 128mb und hat dann nach der letzten Datei alles freigegeben.
    Ich wollte einen Screenshot der Kurve machen, bevor ich den Font auf statisch umstelle... und jetzt bleibt der bei 30mb und läuft mit konstanter Geschwindigkeit durch.
    Dauert jetzt auch nur noch die Hälfte der Zeit.
    Keine Ahnung woran das lag
    Danke aber für den Tipp den Font nicht ständig neu anzusprechen
    Was Microsoft außer Windows und Office noch zu bieten hat.
    Die Kunst das letzte Wort zu haben.
    Die Wahrscheinlichkeit das keine Antwort mehr nach meinem Post kommt liegt bei 80% ^^

    R.I.P. Gulli *6. November 1998 - † 01. Juli 2013

  4. #4
    Team ModMii Avatar von Timon3
    Registriert seit
    Jul 2013
    Beiträge
    497

    Re: C# Programm wird immer langsamer

    Die logische Lösung ist jetzt, immer ein Screenshot-Tool mitlaufen zu lassen, damit sich der Memory Leak nicht traut aufzutreten
    Für diesen Beitrag bedanken sich Roin, KcDaRookie, electric.larry

  5. #5

    Re: C# Programm wird immer langsamer

    Wenn das wieder auftreten sollte, kannst DU mal versuchen den Streamreader in ein using zu kapseln.
    Wenn Du grundsätzlich ein wenig mehr performance rausholen willst, würde ich mit einem Backroundworker arbeiten und das verarbeiten auf mehrere Threads verteilen.
    Auch würde ich immer try/Catch verwenden.

  6. #6
    Temporär Suspendiert :D

    (Threadstarter)

    Avatar von KcDaRookie
    Registriert seit
    Jul 2013
    Beiträge
    265

    Re: C# Programm wird immer langsamer

    @Ta Lun:Eigentlich kann ich Beiträge in denen "DU" groß geschrieben wird echt nicht leiden, das ist eine unschöne Abart die DU dir unbedingt abgewöhnen solltest. Das klingt so möchtegern-Elitär

    Das mit dem Using bzw. Try-Catch(-Finally) bringt mir nur weitere Vorteile bei der Fehlerbehandlung, nicht bei Performance. Natürlich sollte man das nutzen wo möglich, aber da ich hier quasi keine fehlerhaften Eingaben tätigen kann, hab ich das weggelassen.

    Ja, Backgroundworker hatte ich mir angeguckt, sahen mir aber irgendwie zu aufwändig aus.
    Hab das aber jetzt dann doch mal in Angriff genommen und 6 BW erstellt, einer Verteilt die Jobs an die anderen 5 und die konvertieren.
    Hatte dann noch kurzzeit ein Problem, dass die BW das Processed-Label nicht updaten durften, aber das hab ich auch in den Griff bekommen.
    Das Ganze sieht jetzt noch unaufgeräumter aus, aber es klappt:

    Spoiler: 

    Code (C#):
    1. using System;
    2. using System.IO;
    3. using System.Reflection;
    4. using PdfSharp.Drawing;
    5. using PdfSharp.Pdf;
    6.  
    7. using System.Windows.Forms;
    8.  
    9. namespace WindowsFormsApplication4
    10. {
    11.     public partial class Form1 : Form
    12.     {
    13.         public static int filecount;
    14.         const double LINE_SPACING = 6.8;
    15.         const double FONT_SIZE = 7.2;
    16.         public static XFont font;
    17.         public static int processed = 0;
    18.         public Form1()
    19.         {
    20.             AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
    21.             {
    22.                 string resourceName = new AssemblyName(args.Name).Name + ".dll";
    23.                 string resource = Array.Find(this.GetType().Assembly.GetManifestResourceNames(), element => element.EndsWith(resourceName));
    24.  
    25.                 using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resource))
    26.                 {
    27.                     Byte[] assemblyData = new Byte[stream.Length];
    28.                     stream.Read(assemblyData, 0, assemblyData.Length);
    29.                     return Assembly.Load(assemblyData);
    30.                 }
    31.             };
    32.             InitializeComponent();
    33.             invoiceamount();
    34.         }
    35.  
    36.         private void invoiceamount()
    37.         {
    38.             if (!Directory.Exists("input"))
    39.             {
    40.                 label1.Text = "No input folder found.";
    41.                 button1.Enabled = false;
    42.                 button1.Refresh();
    43.             }
    44.             else
    45.             {
    46.                 filecount = Directory.GetFiles("input").Length;
    47.                 if (filecount < 1)
    48.                 {
    49.                     label1.Text = "No files in input folder.";
    50.                     button1.Enabled = false;
    51.                     button1.Refresh();
    52.                 }
    53.                 else
    54.                 {
    55.                     label1.Text = "File count: " + filecount;
    56.                     font = new XFont("Courier New", FONT_SIZE, XFontStyle.Regular, null);
    57.                 }
    58.             }
    59.         }
    60.  
    61.         private void button1_Click(object sender, EventArgs e)
    62.         {
    63.             backgroundWorker2.RunWorkerAsync();
    64.         }
    65.  
    66.         private void convert(string input)
    67.         {
    68.             {
    69.                 StreamReader sr = new StreamReader(input, System.Text.Encoding.Default);
    70.                 PdfDocument document = new PdfDocument();
    71.                 string textAfterFormFeed = "";
    72.                 while (sr.Peek() >= 0 || textAfterFormFeed != "")
    73.                 {
    74.                     PdfPage page = document.AddPage();
    75.                     XGraphics gfx = XGraphics.FromPdfPage(page);
    76.                     bool formFeed = false;
    77.                     string buffer = "";
    78.                     double pos = 30;
    79.                     int lines = 0;
    80.                     if (textAfterFormFeed != "")
    81.                     {
    82.                         gfx.DrawString(textAfterFormFeed, font, XBrushes.Black, new XRect(12, pos, page.Width, page.Height), XStringFormats.TopLeft);
    83.                         pos = pos + LINE_SPACING;
    84.                         lines++;
    85.                         textAfterFormFeed = "";
    86.                     }
    87.                     while (sr.Peek() >= 0 && !formFeed)
    88.                     {
    89.                         buffer = sr.ReadLine();
    90.                         if (buffer != "")
    91.                         {
    92.                             if (buffer[0] =='\x0c')
    93.                             {
    94.                                 formFeed = true;
    95.                                 textAfterFormFeed = buffer.Substring(1);
    96.                             }
    97.                             else
    98.                                 gfx.DrawString(buffer, font, XBrushes.Black, new XRect(12, pos, page.Width, page.Height), XStringFormats.TopLeft);
    99.                             pos = pos + LINE_SPACING;
    100.                             lines++;
    101.                         }
    102.                     }
    103.                 }
    104.                 sr.Close();
    105.                 sr.Dispose();
    106.                 string output = input.Replace("input\\", "");
    107.                 output = output.Replace(".txt", "");
    108.                 document.Save("output\\" + output + ".pdf");
    109.                 document.Close();
    110.             }
    111.         }
    112.  
    113.         private void backgroundWorker2_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    114.         {
    115.             processed = 0;
    116.             if (!Directory.Exists("output"))
    117.             {
    118.                 Directory.CreateDirectory("output");
    119.             }
    120.             foreach (string fileName in Directory.GetFiles("input"))
    121.             {
    122.                 while (true)
    123.                 {
    124.                     if (!backgroundWorker1.IsBusy)
    125.                     {
    126.                         backgroundWorker1.RunWorkerAsync(fileName);
    127.                         break;
    128.                     }
    129.                     if (!backgroundWorker3.IsBusy)
    130.                     {
    131.                         backgroundWorker3.RunWorkerAsync(fileName);
    132.                         break;
    133.                     }
    134.                     if (!backgroundWorker4.IsBusy)
    135.                     {
    136.                         backgroundWorker4.RunWorkerAsync(fileName);
    137.                         break;
    138.                     }
    139.                     if (!backgroundWorker5.IsBusy)
    140.                     {
    141.                         backgroundWorker5.RunWorkerAsync(fileName);
    142.                         break;
    143.                     }
    144.                     if (!backgroundWorker6.IsBusy)
    145.                     {
    146.                         backgroundWorker6.RunWorkerAsync(fileName);
    147.                         break;
    148.                     }
    149.                 }
    150.             }
    151.         }
    152.  
    153.         private void backgroundWorker2_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    154.         {
    155.  
    156.         }
    157.  
    158.         delegate void SetTextCallback();
    159.  
    160.         private void SetText()
    161.         {
    162.             if (this.label2.InvokeRequired)
    163.             {
    164.                 SetTextCallback d = new SetTextCallback(SetText);
    165.                 this.Invoke(d, new object[] { });
    166.             }
    167.             else
    168.             {
    169.                 processed++;
    170.                 if (processed%1000 == 0 || processed == filecount)
    171.                 this.label2.Text = "Processed: " + processed.ToString();
    172.             }
    173.         }
    174.  
    175.         private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    176.         {
    177.             convert((string)e.Argument);
    178.         }
    179.  
    180.         private void backgroundWorker1_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    181.         {
    182.             SetText();
    183.         }
    184.  
    185.         private void backgroundWorker3_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    186.         {
    187.             convert((string)e.Argument);
    188.         }
    189.  
    190.         private void backgroundWorker3_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    191.         {
    192.             SetText();
    193.         }
    194.  
    195.         private void backgroundWorker4_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    196.         {
    197.             convert((string)e.Argument);
    198.         }
    199.  
    200.         private void backgroundWorker4_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    201.         {
    202.             SetText();
    203.         }
    204.  
    205.         private void backgroundWorker5_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    206.         {
    207.             convert((string)e.Argument);
    208.         }
    209.  
    210.         private void backgroundWorker5_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    211.         {
    212.             SetText();
    213.         }
    214.  
    215.         private void backgroundWorker6_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    216.         {
    217.             convert((string)e.Argument);
    218.         }
    219.  
    220.         private void backgroundWorker6_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    221.         {
    222.             SetText();
    223.         }
    224.     }
    225. }
    226.  


    Kleiner Vorher-Nachher vergleich mit 3005 Dateien:
    Vorher:
    Klicke auf die Grafik für eine größere Ansicht 

Name:	vorher.png 
Hits:	13 
Größe:	16,0 KB 
ID:	50995
    Nachher:
    Klicke auf die Grafik für eine größere Ansicht 

Name:	Unbenannt.png 
Hits:	10 
Größe:	17,5 KB 
ID:	50994

    Sind ~2,5 Sekunden bei 3000 Dateien.
    Wenn sich das linear verhält, wären dass alle 70.000-75.000 Dateien 1 Minute die ich spare
    Ich glaube das reicht nicht, um die Zeit wieder reinzuholen, die ich gebraucht habe um die BW zu raffen

    ---------------------------------

    Hmmm... die Debug-Version ist super performant, wenn ich das Ganze als Release-Build raushaue, wird es extrem langsam
    Ich bin verwirrt
    Geändert von KcDaRookie (18.05.18 um 10:25 Uhr) Grund: Nachtrag
    Was Microsoft außer Windows und Office noch zu bieten hat.
    Die Kunst das letzte Wort zu haben.
    Die Wahrscheinlichkeit das keine Antwort mehr nach meinem Post kommt liegt bei 80% ^^

    R.I.P. Gulli *6. November 1998 - † 01. Juli 2013

  7. #7
    Freier Denker
    Registriert seit
    Jul 2013
    Beiträge
    374

    Re: C# Programm wird immer langsamer

    Einfach mal in den Raum geworfen:
    In C++ gilt die Regel "Bei jedem new muss auch ein delete vorkommen". Macht das C# von alleine? Ist der da so schlau?

  8. #8
    ♪♪♫♪♫♫♪ Avatar von KaPiTN
    Registriert seit
    Jul 2013
    Beiträge
    8.159
    ngb:news Artikel
    6

    Re: C# Programm wird immer langsamer

    Du kannst natürlich Objekte mit Dispose zerstören oder , wie Ta Lun anmerkte, in einem Using-Block verwenden, wo nach dem verlassen des Blocks das Objekt verworfen wird.
    Ansonsten erledigt die Garbage Collection die Entsorgung und Speicherfreigabe.


    Grundsätzlich haben die Anwendungen auch immer zuviele Verweise. Ich kann nicht sagen , welchen Einfluß dies auf die Performance hat, aber allein optisch macht das im Code und im Projektordner etwas her, wenn Unnötiges entfernt wird.
    J'irai pisser sur votre bombes
    You can educate a fool, but you cannot make him think

  9. #9

    Re: C# Programm wird immer langsamer

    @KcDaRookie: Da bist Du ein wenig zu empfindlich gewesen, da es einfach in der schnelle passiert ist und bei einem längeren Wort wäre es aufgefallen. Ich kann das aber gut verstehen, werde ja auch nicht gerne angebrüllt.
    Hast aber mit dem BW was gelernt, was doch gut ist.
    Das mit dem Release und Debug macht eigentlich keinen Sinn außer DU (grins) startest das im Debug Modus und meinst nicht nur den Complie.
    Was meine ich damit. Wenn Du im Debug Modus das alle laufen läßt, läufst Du in einem anderen User Kontext (dem vom VS). Wenn Du aber das Program mit doppelklick öffnest, läufst Du im User Kontext von Dir.
    Das muss nicht der gleiche sein. Ich bin mir nicht sicher, wie Deine Formulierung zu interpretieren ist, daher kurz aufklären, was bei Dir die Debug Version ist....

  10. #10
    ♪♪♫♪♫♫♪ Avatar von KaPiTN
    Registriert seit
    Jul 2013
    Beiträge
    8.159
    ngb:news Artikel
    6

    Re: C# Programm wird immer langsamer

    Das mit dem BW bringt aber für die Performance nichts. Wenn ich mich recht erinnere, verwendet der, ebenso wie die Klasse Threading, nur softwareseitiges Multithreading. Die Threads arbeiten also nicht wirklich parallel, sondern wechseln sich in der Verarbeitung ab. Wenn man dann den Aufwand dazu nimmt, um die Threads zu verwalten, schadet es eher.
    Sinn ergibt dieses Multithreading deshalb, weil andere Teile, wie die Oberfläche, nicht auf das Ende von Berechnungen warten müssen.

    Performance kann man erlangen, wenn man auch Multitasking erzeugt, die Threads als wirklich gleichzeitig auf verschiedenen Kernen laufen.

    ich habe damit noch nicht gearbeitet, aber da müßte es eine Klasse Task geben.
    J'irai pisser sur votre bombes
    You can educate a fool, but you cannot make him think

  11. #11
    N.A.C.J.A.C. Avatar von alter_Bekannter
    Registriert seit
    Jul 2013
    Ort
    Midgard
    Beiträge
    3.851

    Re: C# Programm wird immer langsamer

    https://msdn.microsoft.com/de-de/lib...v=vs.110).aspx

    Dann managed dein System die Threadzahl sogar selber. Und du hantierst nicht mit so ekligen kopierten Blöcken.

    Spoiler: 

    Dazu muss man noch anmerken das ein überschreiten der physischen Threadzahll die Performance deutlich verschlechtern kann weil die Kommunikation mit dem RAM im Vergleich zu CPU internen Operationen extrem hohe Latenzen hat. Weil man da drum herum getrickst hat haben wir jetzt so Lücken wie Spectre und Meltdown. Und deswegen fressen die "patches" je nach Implementierung ud Anwendungsfall so viel Leistung.

    Ein Ramzugriff kann dich locker mal 60-200 CPU Taktzyklen an reiner Wartezeit kosten. Jetzt teil deinen CPU Leistung mal durch 60-200, das ist der Worst case durch zuviele Threads ohne irgendwelche anderen Bottlenecks.

    Und Gleichzeitig auch warum Hyperthreading im Schnitt so viel bringt obwohl es keinen zusätzlichen Leistung bringt im CPU Hardware Sinne. Weil ein Hyperthread in fast allen Aspekten Speicherzugriffslatenzen spart, nichts anderes.
    Wichtig: Warum die Installation von Win XP ein Linuxproblem ist.

    Autos töten keine Menschen, sie beschützen sie, vor Menschen mit kleineren Autos.

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •