Leistung mit THREADS geringer ohne?

[Imhotheb]

Irgendiwe ist das aber alles seltsam mit den Threads ... ich habe mal folgendes probiert:

PB 5.31 x86 / Win7_64
Debugger = off
Threadsave = off
Unicode = on
CPU-Cores: 6 phy / 12 log

EDIT: Hab' den Fehler entdeckt ... in CountUp() waren die Variablen kein Quad ...

Code: Alles auswählen

Structure ThData
  Count.q
  Time.i
  ThID.i
EndStructure

Procedure CountUp(*ThData.ThData)
  
  Protected z1.q, z2.q, Count.q = *ThData\Count ;EDIT .q hinzugefügt
  Protected t = ElapsedMilliseconds()
  
  Repeat  ; nach Beispiel von ST4242
    z1 + 1
    z2 + 2
    z2 = z1 * z2
    z2 / 2
    z2 = 0
  Until z1 >= Count       ; Bei Erreichen von #CountMax    
  
  *ThData\Time = ElapsedMilliseconds() - t
  
EndProcedure


#CountMax = 10000000000   ;zaehlen bis
#Threads = 4             ;Anzahl Threads


Dim ThData.ThData(20)
Define th, result.s, thCombTime

;Info:
result = "Zähle bis: " + Chr(9) + Str(#CountMax) + Chr(10)
result + "Threads: " + Chr(9) + Str(#Threads) + " * " + Str(#CountMax / #Threads) + Chr(10)
result + "-------------------" + Chr(10)

;Single/NoThread
ThData(0)\Count = #CountMax
CountUp(@ThData(0))

;Threads starten
For th = 1 To #Threads
  ThData(th)\Count = #CountMax / #Threads
  ThData(th)\ThID = CreateThread(@CountUp(), @ThData(th))
Next

;auf Threads warten / auswerten
For th = 1 To #Threads
  WaitThread(ThData(th)\ThID)
  result + "Thread" + Str(th) + ": " + Chr(9) + Str(ThData(th)\Time) + " ms" + Chr(10)
  thCombTime + ThData(th)\Time
Next

;Thread-Gesamt
result + "-------------------" + Chr(10)
result + "AllThreads: " + Chr(216) + " " + Str(thCombTime / #Threads) + " ms" +
           " / Gesamt: " + Str(thCombTime) + " ms" + Chr(10)
result + "NoThread:  " + Str(ThData(0)\Time) + " ms" + Chr(10)

If MessageRequester("Thread-Test", result + Chr(10) + "Text in Zwischenablage kopieren?",
                    #PB_MessageRequester_YesNo) = #PB_MessageRequester_Yes
  SetClipboardText(result)
EndIf

EDIT: falsche Ergebnisse gelöscht

[Imhotheb]

Hier die neue Werte mit "korrigiertem" Code:

10 Threads:
Zähle bis: 10000000000
Threads: 10 * 1000000000
-------------------
Thread1: 34136 ms
Thread2: 33778 ms
Thread3: 33988 ms
Thread4: 34395 ms
Thread5: 33931 ms
Thread6: 34050 ms
Thread7: 34049 ms
Thread8: 34210 ms
Thread9: 34041 ms
Thread10: 34092 ms
-------------------
AllThreads: Ø 34067 ms / Gesamt: 340670 ms
NoThread: 224091 ms


Mit 6 Threads:
Zähle bis: 10000000000
Threads: 6 * 1666666666
-------------------
Thread1: 39584 ms
Thread2: 39901 ms
Thread3: 39729 ms
Thread4: 39412 ms
Thread5: 39818 ms
Thread6: 39831 ms
-------------------
AllThreads: Ø 39712 ms / Gesamt: 238275 ms
NoThread: 224293 ms


4 Threads:
Zähle bis: 10000000000
Threads: 4 * 2500000000
-------------------
Thread1: 57902 ms
Thread2: 57628 ms
Thread3: 57960 ms
Thread4: 58145 ms
-------------------
AllThreads: Ø 57908 ms / Gesamt: 231635 ms
NoThread: 224394 ms


Das würde doch bedeuten, das ein/kein Thread ca. 224 sek. braucht und bei 10 Threads (wenn man davon ausgeht das es wirklich parallel läuft) nur 34 sek. also ca. 6,5x so schnell.
Bei 6 Threads dann 5,7x und bei 4 Threads ist es immerhin noch 3,8x. Bei 2 Threads ist es fast genau doppelt so schnell wie ein ein einziger Thread.

[ST4242]

Vielen Dank für euere Vielfältigen Tipps.

Aufgrund euerer Anregungen habe ich meinen Code (zum sortieren ein auf MERGE Sort basierter Algo) nochmals angesehen.

Nun habe ich festgestellt wenn in einem Thread häufig die Anweisungen Insertelement und Deleteelement auftauchen, die skalierbarkeit schlecht ist.

Dies habe ich nun umprogrammiert, so dass keine neuen Elemente erzeugt werden, und siehe das die Leistungsteigerung stellt entsprechend der Kernzahl ein.

Gruß Stefan