Geschwindigkeitsproblem mit VB6

12/11/2011 - 12:05 von Hermie | Report spam
Hallo,

ich versuche krampfhaft zu vermeiden, etwas in C/C++ zu machen.
VB6 ist einfach so schön einfach, und ich habe die Erfahrung in C++
nicht, die ich in VB6 habe.

Ich habe folgenden Code:

Dim t&
With m_Targets(t)

.Candidates = nCands

Dim c&
For c = 1 To UBound(nCands)

Dim lIndex2&
lIndex2 = nCands(c).IndexLeft

Dim cPrev&
For cPrev = 1 To UBound(m_Targets(t - 1).Candidates)

Dim lIndex1&
lIndex1 = m_Targets(t -
1).Candidates(cPrev).IndexRight

Dim dblJoinCost As Double
dblJoinCost = pJoinCost(lIndex1, lIndex2)

Dim dblNewPathScore As Double
dblNewPathScore = dblJoinCost + m_Targets(t
- 1).Candidates(cPrev).BestPathScore

If (dblNewPathScore < dblLowest) Then
dblLowest = dblNewPathScore
.Candidates(lCountCand).BestPathText =
m_Targets(t - 1).Candidates(cPrev).BestPathText & "|" &
.Candidates(lCountCand).IndexLeft & "-" & .Candidates(lCountCand).IndexRight
.Candidates(lCountCand).BestPathScore =
dblNewPathScore
End If

Next cPrev
Next c

End With

-

Egal, welche Tricks ich benutze (ich bin schon von Klassen auf UDTs
umgestiegen), habe alle Compiler-Geschwindigkeitsoptimierungen drin,
benutze WithEvents.
Alles hat jeweils einen großen Geschwindigkeitsvorteil gebracht, aber
insgesamt reicht es einfach nicht.

Könntet ihr mir bitte Eure Meinung sagen, ob man das irgendwie mit C++
mischen kann (also oben genannten Code vielleicht als DLL auslagern),
oder ob ich da in VB6 noch was optimieren kann oder ob ich gleich auf
C++ umsteigen müsste?

pJoinCost wird aus einer Sparse-Matrix geholt.

LG,

Hermann
 

Lesen sie die antworten

#1 Thorsten Albers
12/11/2011 - 14:59 | Warnen spam
Hermie schrieb im Beitrag
<j9ljud$q8h$...
Ich habe folgenden Code:



Ich kann nicht viel mehr erkennen als ein paar Schleifen und jede Menge
Verweise auf Speicherobjekte, die zur Laufzeit aufgelöst werden müssen. C++
hàtte genau die gleichen Aufgaben zu bewàltigen, daher ist nicht
anzunehmen, daß da irgendetwas (wesentlich) schneller ablaufen würde.

C++ ist vor allem dann schneller als VB, wenn im Code hàufig und schnell
hintereinander auf VB-Prozeduren zugegriffen wird, die in der VB-Runtime
liegen, weil in VB dafür relativ zeitaufwendige Prozedur-Aufrufe
durchgeführt werden müssen, wàhrend in C++ der entsprechende Prozedur-Code
(je nach Art des Linkens) in den eigenen Code einkompiliert wird.

Der einzige direkte erkennbare Bremser könnte das hier sein:

dblJoinCost = pJoinCost(lIndex1, lIndex2)

pJoinCost wird aus einer Sparse-Matrix geholt.



Was heißt das? Ist pJoinCost() ein Funktionsaufruf oder der Zugriff auf ein
globales Array?

Ansonsten kann man nur raten:
- Verschiebe alle Variablendeklarationen innerhalb des Codes an den Anfang
der Prozedur!
So etwas macht nur in Ausnahmefàllen Sinn. Ob das allerdings für die
Geschwindigkeit eine Rolle spielt, weiß ich nicht (mehr - ist schon etwas
lànger her, daß ich mich damit beschàftigt habe). Aber ist einfach ein
allgemein bewàhrtes Prinzip, die Deklarationen an den Anfang zu stellen.

- Versuche die Objekt-Referenzen zu reduzieren!
'.Candidates(lCountCand)' ist z.B. ein Kandidat dafür, da sich 'lCountCand'
innerhalb des Codes nie àndert, es reicht also am Anfang einmal
Set XYZ = .Candidates(lCountCand)
zu setzen und dann mit 'XYZ' weiterzuarbeiten (und am Ende dann Set XYZ Nothing).

- Überdenke das Programm-Design!
Verschachtelte Schleifen benötigen logischerweise Zeit. So manches 'mal
làßt sich so etwas durch Änderung des Programm-Designs, in diesem Fall
durch Änderung der Datenspeicherung-Organisation beheben.

Mehr làßt sich dazu m.E. ohne weitere Kenntnis des Programmes nicht sagen.
Noch einmal: C++ dürfte Dir hier kaum etwas bringen.

Thorsten Albers

gudea at gmx.de

Ähnliche fragen