Is here way, how do this faster?

[Petr]

Hi. This sub create a "hole" in software layer (area with alpha 0) so is in this area then hardware layer visible, if _DISPLAYORDER _HARDWARE, _SOFTWARE is used.  After inserting this SUB to program is mouse reaction time very slower. X1, Y1, X2, Y2 can be every time other. Is here some way, how take it faster?

MEM is used here, because it calculate none colors coopoerations between color with alpha and software background. This sub is for creating transparent area in software layer.

Code: QB64: [Select]

1. SUB SCLS (x1 AS LONG, y1 AS LONG, x2 AS LONG, y2 AS LONG)
2.       a = _DEST
3.     DIM m AS _MEM, kolor2 AS _UNSIGNED LONG, x AS LONG, y AS LONG
4.     m = _MEMIMAGE(a)
5.     kolor2~& = &H00000000
6.     IF y1 > y2 THEN SWAP y1, y2
7.     IF x1 > x2 THEN SWAP x1, x2
8.  
9.     'memory out of range prevent
10.     IF x1 < 0 THEN x1 = 0
11.     IF y1 < 0 THEN y1 = 0
12.     IF x2 > _WIDTH(a) - 1 THEN x2 = _WIDTH(a) - 1
13.     IF y2 > _HEIGHT(a) - 1 THEN y2 = _HEIGHT(a) - 1
14.     '---------------------------
15.     LINE (W(3).X1, W(3).Y1)-(W(3).X2, W(3).Y2), _RGB32(183, 194, 200), BF 'create border between software and hardware area
16.  
17.     y = y1
18.     x = x1
19.     DO UNTIL y > y2
20.         DO UNTIL x > x2
21.             _MEMPUT m, m.OFFSET + 4 * ((_WIDTH(a) * y) + x), kolor2~&
22.             x = x + 1
23.         LOOP
24.         x = x1: y = y + 1
25.     LOOP
26.     _MEMFREE m
27. END SUB
28.  
29.  

[SMcNeill]

Move the math outside the loops as much as possible.  See the difference in performance between these versions:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(640, 480, 32)
2.  
3. CLS , &HFFF0F000
4. t## = TIMER
5. FOR i = 1 TO 10000
6.     Original_SCLS 100, 100, 200, 200
7. NEXT
8. t1## = TIMER
9. FOR i = 1 TO 10000
10.     Steve_SCLS 100, 100, 200, 200
11. NEXT
12. t2## = TIMER
13.  
14.  
15.  
16. PRINT USING "##.##### seconds for original"; t1## - t##
17. PRINT USING "##.##### seconds for Steve"; t2## - t1##
18.  
19.  
20. SUB Steve_SCLS (x1 AS LONG, y1 AS LONG, x2 AS LONG, y2 AS LONG)
21.     a = _DEST
22.     STATIC m AS _MEM
23.     DIM x AS LONG, y AS LONG
24.     DIM w AS LONG, o AS _OFFSET
25.     m = _MEMIMAGE(a)
26.     kolor2~& = &H00000000
27.     IF y1 > y2 THEN SWAP y1, y2
28.     IF x1 > x2 THEN SWAP x1, x2
29.  
30.     'memory out of range prevent
31.     IF x1 < 0 THEN x1 = 0
32.     IF y1 < 0 THEN y1 = 0
33.     w = _WIDTH(a): h = _HEIGHT(a)
34.     IF x2 > w - 1 THEN x2 = w - 1
35.     IF y2 > h - 1 THEN y2 = h - 1
36.     '---------------------------
37.     '   LINE (W(3).X1, W(3).Y1)-(W(3).X2, W(3).Y2), _RGB32(183, 194, 200), BF 'create border between software and hardware area
38.  
39.     y = y1 * w * 4
40.     y2 = y2 * w * 4
41.     x1 = x1 * 4
42.     x2 = x2 * 4
43.     x = x1
44.     w = w * 4
45.     $CHECKING:OFF
46.     DO UNTIL y > y2
47.         o = m.OFFSET + y
48.         DO UNTIL x > x2
49.             _MEMPUT m, o + x, 0 AS _UNSIGNED LONG
50.             x = x + 4
51.         LOOP
52.         x = x1: y = y + w
53.     LOOP
54.     $CHECKING:ON
55.     '_MEMFREE m 'No need to memfree as we keep the memblock available to point to other images in the future
56. END SUB
57.  
58.  
59. SUB Original_SCLS (x1 AS LONG, y1 AS LONG, x2 AS LONG, y2 AS LONG)
60.     a = _DEST
61.     DIM m AS _MEM, kolor2 AS _UNSIGNED LONG, x AS LONG, y AS LONG
62.     m = _MEMIMAGE(a)
63.     kolor2~& = &H00000000
64.     IF y1 > y2 THEN SWAP y1, y2
65.     IF x1 > x2 THEN SWAP x1, x2
66.  
67.     'memory out of range prevent
68.     IF x1 < 0 THEN x1 = 0
69.     IF y1 < 0 THEN y1 = 0
70.     IF x2 > _WIDTH(a) - 1 THEN x2 = _WIDTH(a) - 1
71.     IF y2 > _HEIGHT(a) - 1 THEN y2 = _HEIGHT(a) - 1
72.     '---------------------------
73.     'LINE (W(3).X1, W(3).Y1)-(W(3).X2, W(3).Y2), _RGB32(183, 194, 200), BF 'create border between software and hardware area
74.  
75.     y = y1
76.     x = x1
77.     $CHECKING:OFF
78.     DO UNTIL y > y2
79.         DO UNTIL x > x2
80.             _MEMPUT m, m.OFFSET + 4 * ((_WIDTH(a) * y) + x), kolor2~&
81.             x = x + 1
82.         LOOP
83.         x = x1: y = y + 1
84.     LOOP
85.     $CHECKING:ON
86.     _MEMFREE m
87. END SUB

Notice the difference in the complexity of the math between both of our innermost loops:

_MEMPUT m, m.OFFSET + 4 * ((_WIDTH(a) * y) + x), kolor2~&

vs

_MEMPUT m, o + x, 0 AS _UNSIGNED LONG

[Petr]

This is an absolutely incredible boost in performance! Thank you so much for your help, Steve! I have the gift of slowing down anything ...

[SMcNeill]

And, let's swap out out _MEMPUT command for a _MEMFILL and see how it performs for us:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(640, 480, 32)
2.  
3. CLS , &HFFF0F000
4. t## = TIMER
5. FOR i = 1 TO 10000
6.     Original_SCLS 100, 100, 200, 200
7. NEXT
8. t1## = TIMER
9. CLS , &HFFF0F000
10. FOR i = 1 TO 1000000
11.     Steve_SCLS 100, 100, 200, 200
12. NEXT
13. t2## = TIMER
14.  
15.  
16.  
17. PRINT USING "##.######## seconds for original"; t1## - t##
18. PRINT USING "##.######## seconds for Steve"; t2## - t1##
19. PRINT
20. PRINT "Notice the size of our FOR loops -- Steve_SCLS is running 100 times more,"
21. PRINT "with very little time difference!"
22.  
23.  
24.  
25. SUB Steve_SCLS (x1 AS LONG, y1 AS LONG, x2 AS LONG, y2 AS LONG)
26.     a = _DEST
27.     STATIC m AS _MEM
28.     DIM x AS LONG, y AS LONG
29.     DIM w AS LONG, o AS _OFFSET
30.     m = _MEMIMAGE(a)
31.     kolor2~& = &H00000000
32.     IF y1 > y2 THEN SWAP y1, y2
33.     IF x1 > x2 THEN SWAP x1, x2
34.  
35.     'memory out of range prevent
36.     IF x1 < 0 THEN x1 = 0
37.     IF y1 < 0 THEN y1 = 0
38.     w = _WIDTH(a): h = _HEIGHT(a)
39.     IF x2 > w - 1 THEN x2 = w - 1
40.     IF y2 > h - 1 THEN y2 = h - 1
41.     '---------------------------
42.     '   LINE (W(3).X1, W(3).Y1)-(W(3).X2, W(3).Y2), _RGB32(183, 194, 200), BF 'create border between software and hardware area
43.  
44.     y = y1 * w * 4 + x1 * 4
45.     y2 = y2 * w * 4
46.     xstop = x2 * 4 - x1 * 4
47.     w = w * 4
48.     $CHECKING:OFF
49.     DO UNTIL y > y2
50.         o = m.OFFSET + y
51.         _MEMFILL m, o, xstop, 0 AS _UNSIGNED _BYTE
52.         y = y + w
53.     LOOP
54.     $CHECKING:ON
55.     '_MEMFREE m 'No need to memfree as we keep the memblock available to point to other images in the future
56. END SUB
57.  
58.  
59. SUB Original_SCLS (x1 AS LONG, y1 AS LONG, x2 AS LONG, y2 AS LONG)
60.     a = _DEST
61.     DIM m AS _MEM, kolor2 AS _UNSIGNED LONG, x AS LONG, y AS LONG
62.     m = _MEMIMAGE(a)
63.     kolor2~& = &H00000000
64.     IF y1 > y2 THEN SWAP y1, y2
65.     IF x1 > x2 THEN SWAP x1, x2
66.  
67.     'memory out of range prevent
68.     IF x1 < 0 THEN x1 = 0
69.     IF y1 < 0 THEN y1 = 0
70.     IF x2 > _WIDTH(a) - 1 THEN x2 = _WIDTH(a) - 1
71.     IF y2 > _HEIGHT(a) - 1 THEN y2 = _HEIGHT(a) - 1
72.     '---------------------------
73.     'LINE (W(3).X1, W(3).Y1)-(W(3).X2, W(3).Y2), _RGB32(183, 194, 200), BF 'create border between software and hardware area
74.  
75.     y = y1
76.     x = x1
77.     $CHECKING:OFF
78.     DO UNTIL y > y2
79.         DO UNTIL x > x2
80.             _MEMPUT m, m.OFFSET + 4 * ((_WIDTH(a) * y) + x), kolor2~&
81.             x = x + 1
82.         LOOP
83.         x = x1: y = y + 1
84.     LOOP
85.     $CHECKING:ON
86.     _MEMFREE m
87. END SUB

Careful application of math and use of _MEMFILL gives us a routine about 80 times faster than the original.  :D

[Petr]

Yeah, I see how you count the area where the memory is to be filled and then fill that area in rows, you load it in the blocks. I was thinking about how do it this way (my version of it is recording point by point). Well, this is a rocket. Much more usable than my version. Thanks!