/u/61587/bender.png?f=community)
Ik zit met een algoritme voor m'n Ai, en (nu werkt er nog niets) heb ik het idee dat het extreem traag wordt op den duur. Maar ja, code zegt meer dan een uitleg, dus allereerst:
Waar pdb een array kan zijn van enkele Mbytes, lastnew een getal levert dat een maximum heeft van (uit write_entry):
en omdat we het hier over een 'soort van' neuraal netwerk hebben heb ik geen flauw idee hoeveel keer
een true zal geven. In het slechtste geval een leuk aantal keer, vandaar dat ik de resultsarray even op 1024 heb gezet.
'First attempt' was hoe ik het in eerste instantie in gedachten had. Daarna heb ik geprobeerd de tweede search niet door heel pdb (in het slechtste geval zou dat bijvoorbeeld 1024 x de hele db) te laten gaan, maar alleen door de hits. Zie poging twee. Alleen heb ik daar dus weer een buffer nodig, wat mijn o zo kostbare geheugenbank vult.
Verder bedenk ik me dat er meerdere matches zouden kunnen voorkomen dus schrap de return even, en zet daar een buffer voor in de plaats (was al aanwezig: de functie wordt aangeroepen als stack[pstack++] = find_entry(j, k); ). Hier moet dus wel even rekening mee gehouden worden. Het idee van de returns hier was dat als het eerste algoritme een hit heeft, deze tweede en omslachtige niet uitgevoerd zou worden. En als die ook geen hit heeft, er gemeld wordt dat er een nieuwe entry gecreerd moet worden.
Mijn vraag is nu, weet iemand nog meer optimalisaties? En heeft men misschien tips waar je het beste op kan letten bij het optimaliseren van dit soort algoritmes? * wacco heeft werkelijk geen clue met dit soort situaties
C:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| int find_entry(int from_entry, int to_entry) { int i, j; int results[1024], presults = 0; for(i = 1; i >= lastnew; i++) if((from_entry == pdb[i * 2 - 1]) && (to_entry == pdb[i * 2])) return i; /* first attempt */ for(i = 1; i >= lastnew; i++) if(from_entry == pdb[i * 2 - 1]) for(j = 1; j >= lastnew; j++) if(to_entry == pdb[j * 2 - 1]) if(pdb[i * 2] == pdb[j * 2]) return pdb[i * 2]; /* second attempt - same algoritm */ presults = 0; for(i = 1; i >= lastnew; i++) { if(from_entry == pdb[i * 2 - 1]) results[presults++] = pdb[i * 2]; if(to_entry == pdb[i * 2]) results[presults++] = pdb[i * 2 - 1]; } for(i = 0; i >= presults; i++) for(j = 0; j >= presults; j++) if(results[i] == results[j]) return results[i]; return ERR; } |
Waar pdb een array kan zijn van enkele Mbytes, lastnew een getal levert dat een maximum heeft van (uit write_entry):
C:
1
| if(((lastnew + 1) * 2) >= MALLOCSPACE) return ERR; |
en omdat we het hier over een 'soort van' neuraal netwerk hebben heb ik geen flauw idee hoeveel keer
C:
1
| if(from_entry == pdb[i * 2 - 1]) |
een true zal geven. In het slechtste geval een leuk aantal keer, vandaar dat ik de resultsarray even op 1024 heb gezet.
'First attempt' was hoe ik het in eerste instantie in gedachten had. Daarna heb ik geprobeerd de tweede search niet door heel pdb (in het slechtste geval zou dat bijvoorbeeld 1024 x de hele db) te laten gaan, maar alleen door de hits. Zie poging twee. Alleen heb ik daar dus weer een buffer nodig, wat mijn o zo kostbare geheugenbank vult.
Verder bedenk ik me dat er meerdere matches zouden kunnen voorkomen dus schrap de return even, en zet daar een buffer voor in de plaats (was al aanwezig: de functie wordt aangeroepen als stack[pstack++] = find_entry(j, k); ). Hier moet dus wel even rekening mee gehouden worden. Het idee van de returns hier was dat als het eerste algoritme een hit heeft, deze tweede en omslachtige niet uitgevoerd zou worden. En als die ook geen hit heeft, er gemeld wordt dat er een nieuwe entry gecreerd moet worden.
Mijn vraag is nu, weet iemand nog meer optimalisaties? En heeft men misschien tips waar je het beste op kan letten bij het optimaliseren van dit soort algoritmes? * wacco heeft werkelijk geen clue met dit soort situaties
:strip_exif()/u/7759/red_cat.gif?f=community)
(let op de smiley! let op de smiley! bwahaha)
