Avoiding implicit try finally section/fi: what changed

Revision 3 to 4. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		# Epäsuoran try finally lohkon välttäminen
2	2
3	3		## Yleistä
4	4
5	5		Koodin optimoinnissa se auttaa ymmärtämään, että [[Compiler/fi\|kääntäjä]] käärii tiettyjä koodirakenteita epäsuorasti [[Try/fi\|try]] … [[Finally/fi\|finally]]-[[Block/fi\|lohkoon]]. Tämä on tarpeen aina, kun käytetään sellaisia [[Variable/fi\|muuttujia]], kuten [[Ansistring\|ansiString]], [[Variant\|variants]] tai [[Dynamic array/fi\|dynaamisia taulukoita]] jotka edellyttävät [[Initialization\|initialization]] ja [[Finalization\|finalization]] (esim. kun standardi [[Procedure/fi\|aliohjelmat]] `initialize` ja `finalize` tarvitaan oikean muistin allokoinnin ja hankitun muistin vapauttamiseksi).
6	6
7	7		Tällöin kääntäjä varmistaa, että msg: n viitenumero lasketaan asianmukaisesti, kun menettely doSomething poistuu poikkeuksella. Usein tämä voi kuitenkin aiheuttaa merkittäviä haitallisia vaikutuksia tuotetun koodin nopeuteen.
8	8
9	9		Tämä oli ongelma, joka oli `fpc-devel` -sähköpostilistan aiheketjussa <http://www.mail-archive.com/fpc-devel@lists.freepascal.org/msg01367.html> `TList` slowness classes .
10	10
11	11		Huomaa, että väliaikaiset `ansiString`-muuttujat voidaan luoda epäsuorasti. Ainoa tapa olla täysin varma siitä, mitä todellisuudessa tehdään, on lukea [[Assembler/fi\|assemblerin]] ulostulo.
12	12
13	13		## Mahdolliset ratkaisut
14	14
15	15		- Käytetään [[sImplicitExeptions\|{$implicitexceptions off}]]: Varmistetaan, että tämä koskee vain julkaistuja versioita. Virheenjäljitys voi muuttua hankalaksi, kun siirrytään erityisesti muistivuotoihin ja korruptioon.
16	16		- Irrotetaan harvoin käytetty koodi, joka aiheuttaa implisiittisen `try…finally` eri aliohjelmiin. (Voidaan käyttää aliohjelmissa aliohjelmia)
17	17		- Käytetään [[Const\|const parametreja]] arvoparametrien sijaan. Näin vältetään tarve muuttaa viittausosoitusta, mutta tilapäiset muuttujat voivat edelleen olla ongelma.
18	18		- Käytetään [[Global variables\|globaaleja muuttujia]]: Sinun on kuitenkin oltava varovainen uusintakysymyksissä, mutta väliaikaiset muuttujat voivat silti olla ongelma.
19	19		- Käytetään ei-viitteellisiä tyyppejä, kuten [[Shortstring\|shortstring]].
20	20
21	21		## riskejä ja milloin niitä sovelletaan
22	22
23	23		> Warning: Nämä poikkeuskehykset luodaan syystä. Jos niistä jätetään poikkeus niin koodiin jään muistivuoto mahdollisuus
24	24
25	25		Vuonna 2007 [[sImplicitExceptions\|{$implicitExceptions}]] lisättiin [`strutils`](https://www.freepascal.org/docs-html/rtl/strutils/index.html)-[[Unit/fi\|käännösyksikköön]]. Jota [sysutils](https://www.freepascal.org/docs-html/rtl/sysutils/index.html) on luultavasti seurannut. Tätä varten noudatettiin seuraavaa lähestymistapaa:
26	26
27	27		- [[Routine/fi\|Rutiini]], joka kutsuu rutiinia, joka [[Raise/fi\|nostaa]] poikkeuksia, on vaarallinen - esim. [`strToInt`](https://www.freepascal.org/docs-html/rtl/sysutils/strtoint.html), mutta ei [`strToIntDef`](https://www.freepascal.org/docs-html/rtl/sysutils/strtointdef.html).
28	28		- Poikkeuksia aiheuttavat rutiinit on huomioitavia.
29	29		- Hyvin suuret rutiinit eivät ole vaivan arvoista, koska riski ja alhaiset edut - esim. [päivämäärän muotoilurutiinit](https://www.freepascal.org/docs-html/rtl/sysutils/datetimeroutines.html).
30	30		- Desimaalilukujen käyttö voi nostaa poikkeuksia, jotka muunnetaan [[sysutils\|sysUtils]]-ohjelmien avulla. En ole varma, onko tämä todellakin riittävä syy, mutta ohitin Desimaalilukujen käytön käyttämällä näitä rutiineja aluksi tästä syystä.
31	31
32	32		Jos havaitset näitä muutoksia, ota yhteyttä Marcoviin.
33	33
34	34		## Demo-ohjelma
35	35
36	36		Alla on pieni demo-[[Program/fi\|ohjelma]]
37	37
38	38		Sen suorittaessaan osoittaa selvästi, että epäsuoran `try … finally` välttäminen mhdollistaa koodin suorittamisen paljon nopeammin. Kun suoritin tämän ohjelman järjestelmässäni, sain tuloksen:
39	39
40		-	~~`time of fooNormal: 141`\~~
41		-	~~`time of fooFaster: 17`~~
	40	+	```
	41	+	time of fooNormal: 141
	42	+	time of fooFaster: 17
	43	+	```
42	44
43	45		- Tässä näytetään temppu, jolla vältetään epäsuoria `try … finally` - lohkoja (muuttamatta koodin merkitystä tai turvallisuutta) joissakin tapauksissa (kun sinun ei tarvitse tosiasiallisesti käyttää tätä [[Ansistring\|AnsiString]]/
44	46
45	47		[[Variant\|Variant-tyyppiä]]/ jotakin muuta tyyppiä joka kerta kun aliohjelmaa kutsutaan mutta vain jos jollakin parametrilla on tietty arvo).
46	48
47	49		``` pascal
48	50		program implicitExceptionDemo(input, output, stderr);
49	51
50	52		// for exceptions
51	53		{$mode objfpc}
52	54		// data type 'string' refers to 'ansistring'
53	55		{$longstrings on}
54	56
55	57		uses
56	58		{$IFDEF UNIX}
57	59		// baseUnix, unix needed only to implement clock
58	60		BaseUnix, Unix,
59	61		{$ENDIF}
60	62		sysUtils;
61	63
62	64		function clock(): int64;
63	65
64	66		var
65	67		{$IFDEF UNIX}
66	68		dummy: tms;
67	69		{$ELSE}
68	70		TS : TTimeStamp;
69	71		{$ENDIF}
70	72		begin
71	73		{$IFDEF UNIX}
72	74		clock := fpTimes(dummy);
73	75		{$ELSE}
74	76		TS:=DateTimeToTimeStamp(Now);
75	77		result := TS.Time;
76	78		{$ENDIF}
77	79		end;
78	80
79	81		// Note: when fooNormal and fooFaster are called
80	82		// i is always >= 0, so no exception is ever actually raised.
81	83		// So string constants SNormal and SResString are not really used.
82	84
83	85		procedure fooNormal(i: integer);
84	86		var
85	87		s: string;
86	88		begin
87	89		if i = -1 then
88	90		begin
89	91		s := 'Some operation with AnsiString';
90	92		raise exception.create(s);
91	93		end;
92	94		end;
93	95
94	96		procedure fooFaster(i: integer);
95	97		procedure raiseError;
96	98		var
97	99		s: string;
98	100		begin
99	101		s := 'Some operation with AnsiString';
100	102		raise exception.create(s);
101	103		end;
102	104		begin
103	105		if i = -1 then
104	106		begin
105	107		raiseError;
106	108		end;
107	109		end;
108	110
109	111		// M A I N =================================================
110	112		const
111	113		testCount = 10000000;
112	114		var
113	115		i: integer;
114	116		start: int64;
115	117		begin
116	118		start := clock();
117	119		for i := 0 to testCount do
118	120		begin
119	121		fooNormal(i);
120	122		end;
121	123		writeLn('time of fooNormal: ', clock() - start);
122	124
123	125		start := clock();
124	126		for i := 0 to testCount do
125	127		begin
126	128		fooFaster(i);
127	129		end;
128	130		writeLn('time of fooFaster: ', clock() - start);
129	131		end.
130	132		```
131	133
132	134		Laittamalla `raiseError` toiseen [[Scope\|näkyvyyteen]] `fooFaster` aliohjelmassa, keskeysten käsittely ei tule osaksi pääkäyttöistä suoritusosaa.
133	135
134	136		---
135	137		From the Free Pascal wiki, page "Avoiding implicit try finally section/fi", as it stood on 2022-08-06 after a change by Kai Burghardt, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history