Fast(er) Dereference in VB6

In a form:

VB Code:

Option Explicit
 
Private Declare Function GetTickCount Lib "kernel32" () As Long
 
Private Sub Command1_Click()
 
    Dim lng As Long
    Dim i As Long
    Dim Start As Long
    Dim Finish As Long
    
    lng = 1234567890
    
    Start = GetTickCount()
    For i = 0 To 100000000
        Call Deref1(VarPtr(lng))
    Next
    Finish = GetTickCount - Start
    Text1.Text = Finish
    
    Start = GetTickCount()
    For i = 0 To 100000000
        Call Deref2(VarPtr(lng))
    Next
    Finish = GetTickCount - Start
    Text2.Text = Finish
    
End Sub

IN a module:

VB Code:

Option Explicit
 
Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long)
Private Declare Sub GetMem4 Lib "msvbvm60" (ByVal Addr As Long, Value As Long)
 
 
Public Function Deref1(Addr As Long) As Long
    CopyMemory ByVal VarPtr(Deref1), ByVal Addr, 4
End Function
 
Public Function Deref2(Addr As Long) As Long
    GetMem4 Addr, Deref2
End Function

Compiled with all optimisations on I get:

Deref1:6860
Deref2:3484

Hey, try the PutMem's!

Nice.

I've been planning a Codebank thread on the fastest ways to use pointers in VB. This just made it in :D

Looking at returning the value directly onto a long variable by pretending - using voids and what not - that VB is calling a function, when really it's just running some assembly.

That way it can go in-line, and we can dump all that expensive HRESULT stuff (although I can get it to do similar by declaring the GetMem in a typelib)

Getting a bit stuck on the VB function stack frame, though. Intels 'wonderful' byte ordering is err 'wonderful' ?

Penegate:

I followed your link above. I have to admit that I'd never thought of using driver level API's but there's a load there that will make some of my code absolutely fly.

Nice one mate. Much appreciated, indeed

:) :thumb:

If you re-Declare as

VB Code:

Public Declare Sub DerefLong Lib "msvbvm60" Alias "GetMem4" (Addr As Long, Value As Long)

and use this lot

VB Code:

Private Sub Command1_Click()
 
    Dim lng As Long
    Dim lng2 As Long
    Dim i As Long
    Dim Start As Long
    Dim Finish As Long
    
    lng = 1234567890
    
    Start = GetTickCount()
    For i = 0 To 100000000
        CopyMemory lng2, lng, 4
    Next
    Finish = GetTickCount - Start
    Text1.Text = Finish
    
    lng2 = 0
    
    Start = GetTickCount()
    For i = 0 To 100000000
        DerefLong lng, lng2
    Next
    Finish = GetTickCount - Start
    Text2.Text = Finish
    
End Sub

Then the performance is:
CopyMemory: 4906
DerefLong:: 1781

Now that can't be bad for 100million iterations, can it :thumb:

The lesson here, methinks, is that calls to VB functions severely inhibit the speed of this function.

(BTW - this is a different computer - I'm at home, now)

whats the purpose of dereference?

A lot of data in a computer program is stored as a pointer to it's memory address.

Dereferencing means convert the address to the value it points to.

Something that you can do in almost every language apart from VB!

Here's an example project extensively using this form of dereferencing.

It is an implementation of some basic matrix handling routines. I have no idea how the speed compares to implementing matrices using a safearray.

What do you think?

What's it supposed to output? I get 70.

Yup: it's the matrix multiplication of
(1 2 3 4)

(5
6
7
8)

which returns a 1x1 matrix containing the element 70.

If you want a more complex example you can try this:

VB Code:

Sub Main()
 
    On Error GoTo ERR_Main
    
    Dim pM1 As Long
    Dim pM2 As Long
    Dim pM3 As Long
    Dim i As Long
    Dim j As Long
    
    pM1 = MCreate(2, 4)
    pM2 = MCreate(4, 3)
    
    PutElement pM1, 1, 1, 1
    PutElement pM1, 1, 2, 2
    PutElement pM1, 1, 3, 3
    PutElement pM1, 1, 4, 4
    PutElement pM1, 2, 1, 5
    PutElement pM1, 2, 2, 6
    PutElement pM1, 2, 3, 7
    PutElement pM1, 2, 4, 8
    
    PutElement pM2, 1, 1, 1
    PutElement pM2, 1, 2, 2
    PutElement pM2, 1, 3, 3
    PutElement pM2, 2, 1, 4
    PutElement pM2, 2, 2, 5
    PutElement pM2, 2, 3, 6
    PutElement pM2, 3, 1, 7
    PutElement pM2, 3, 2, 8
    PutElement pM2, 3, 3, 9
    PutElement pM2, 4, 1, 10
    PutElement pM2, 4, 2, 11
    PutElement pM2, 4, 3, 12
    
    pM3 = MMultiply(pM1, pM2)
    
    For i = 1 To MRows(pM3)
        For j = 1 To MColumns(pM3)
            Debug.Print GetElement(pM3, i, j), ;
        Next
        Debug.Print
    Next
 
    Exit Sub
    
ERR_Main:
    Err.Raise Err.Number, Err.Source, Err.Description, Err.HelpFile, Err.HelpContext
End Sub

The answer should be

(70 80 90
158 184 210)

Any thoughts on this matrix thing on getting it to be more efficient?