Avoiding implicit try finally section/fi: what changed

Revision 4 to 5. 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		-	~~```~~
	40	+	```text
41	41		time of fooNormal: 141
42	42		time of fooFaster: 17
43	43		```
44	44
45	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]]/
46	46
47	47		[[Variant\|Variant-tyyppiä]]/ jotakin muuta tyyppiä joka kerta kun aliohjelmaa kutsutaan mutta vain jos jollakin parametrilla on tietty arvo).
48	48
49	49		``` pascal
50	50		program implicitExceptionDemo(input, output, stderr);
51	51
52	52		// for exceptions
53	53		{$mode objfpc}
54	54		// data type 'string' refers to 'ansistring'
55	55		{$longstrings on}
56	56
57	57		uses
58	58		{$IFDEF UNIX}
59	59		// baseUnix, unix needed only to implement clock
60	60		BaseUnix, Unix,
61	61		{$ENDIF}
62	62		sysUtils;
63	63
64	64		function clock(): int64;
65	65
66	66		var
67	67		{$IFDEF UNIX}
68	68		dummy: tms;
69	69		{$ELSE}
70	70		TS : TTimeStamp;
71	71		{$ENDIF}
72	72		begin
73	73		{$IFDEF UNIX}
74	74		clock := fpTimes(dummy);
75	75		{$ELSE}
76	76		TS:=DateTimeToTimeStamp(Now);
77	77		result := TS.Time;
78	78		{$ENDIF}
79	79		end;
80	80
81	81		// Note: when fooNormal and fooFaster are called
82	82		// i is always >= 0, so no exception is ever actually raised.
83	83		// So string constants SNormal and SResString are not really used.
84	84
85	85		procedure fooNormal(i: integer);
86	86		var
87	87		s: string;
88	88		begin
89	89		if i = -1 then
90	90		begin
91	91		s := 'Some operation with AnsiString';
92	92		raise exception.create(s);
93	93		end;
94	94		end;
95	95
96	96		procedure fooFaster(i: integer);
97	97		procedure raiseError;
98	98		var
99	99		s: string;
100	100		begin
101	101		s := 'Some operation with AnsiString';
102	102		raise exception.create(s);
103	103		end;
104	104		begin
105	105		if i = -1 then
106	106		begin
107	107		raiseError;
108	108		end;
109	109		end;
110	110
111	111		// M A I N =================================================
112	112		const
113	113		testCount = 10000000;
114	114		var
115	115		i: integer;
116	116		start: int64;
117	117		begin
118	118		start := clock();
119	119		for i := 0 to testCount do
120	120		begin
121	121		fooNormal(i);
122	122		end;
123	123		writeLn('time of fooNormal: ', clock() - start);
124	124
125	125		start := clock();
126	126		for i := 0 to testCount do
127	127		begin
128	128		fooFaster(i);
129	129		end;
130	130		writeLn('time of fooFaster: ', clock() - start);
131	131		end.
132	132		```
133	133
134	134		Laittamalla `raiseError` toiseen [[Scope\|näkyvyyteen]] `fooFaster` aliohjelmassa, keskeysten käsittely ei tule osaksi pääkäyttöistä suoritusosaa.
135	135
136	136		---
137	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