|
os161-1.99
|
00001 00002 /* The goal here is to produce lots of .text pages. 00003 * We'd like to create a lot of page faults on text pages. 00004 */ 00005 00006 void call_all_loop(int count); 00007 void call_all(void); 00008 00009 /* keep this small */ 00010 #define FUNCTION_LOOP (2) 00011 00012 /* Create prototypes for all of the functions */ 00013 #define PROTFUNC(num) int func_##num(void); 00014 PROTFUNC(0); PROTFUNC(1); PROTFUNC(2); PROTFUNC(3); PROTFUNC(4); 00015 PROTFUNC(5); PROTFUNC(6); PROTFUNC(7); PROTFUNC(8); PROTFUNC(9); 00016 PROTFUNC(10); PROTFUNC(11); PROTFUNC(12); PROTFUNC(13); PROTFUNC(14); 00017 PROTFUNC(15); PROTFUNC(16); PROTFUNC(17); PROTFUNC(18); PROTFUNC(19); 00018 PROTFUNC(20); PROTFUNC(21); PROTFUNC(22); PROTFUNC(23); PROTFUNC(24); 00019 PROTFUNC(25); PROTFUNC(26); PROTFUNC(27); PROTFUNC(28); PROTFUNC(29); 00020 PROTFUNC(30); PROTFUNC(31); PROTFUNC(32); PROTFUNC(33); PROTFUNC(34); 00021 PROTFUNC(35); PROTFUNC(36); PROTFUNC(37); PROTFUNC(38); PROTFUNC(39); 00022 PROTFUNC(40); PROTFUNC(41); PROTFUNC(42); PROTFUNC(43); PROTFUNC(44); 00023 PROTFUNC(45); PROTFUNC(46); PROTFUNC(47); PROTFUNC(48); PROTFUNC(49); 00024 PROTFUNC(50); PROTFUNC(51); PROTFUNC(52); PROTFUNC(53); PROTFUNC(54); 00025 PROTFUNC(55); PROTFUNC(56); PROTFUNC(57); PROTFUNC(58); PROTFUNC(59); 00026 PROTFUNC(60); PROTFUNC(61); PROTFUNC(62); PROTFUNC(63); PROTFUNC(64); 00027 PROTFUNC(65); PROTFUNC(66); PROTFUNC(67); PROTFUNC(68); PROTFUNC(69); 00028 PROTFUNC(70); PROTFUNC(71); PROTFUNC(72); PROTFUNC(73); PROTFUNC(74); 00029 PROTFUNC(75); PROTFUNC(76); PROTFUNC(77); PROTFUNC(78); PROTFUNC(79); 00030 PROTFUNC(80); PROTFUNC(81); PROTFUNC(82); PROTFUNC(83); PROTFUNC(84); 00031 PROTFUNC(85); PROTFUNC(86); PROTFUNC(87); PROTFUNC(88); PROTFUNC(89); 00032 PROTFUNC(90); PROTFUNC(91); PROTFUNC(92); PROTFUNC(93); PROTFUNC(94); 00033 PROTFUNC(95); PROTFUNC(96); PROTFUNC(97); PROTFUNC(98); PROTFUNC(99); 00034 PROTFUNC(100); PROTFUNC(101); PROTFUNC(102); PROTFUNC(103); PROTFUNC(104); 00035 PROTFUNC(105); PROTFUNC(106); PROTFUNC(107); PROTFUNC(108); PROTFUNC(109); 00036 PROTFUNC(110); PROTFUNC(111); PROTFUNC(112); PROTFUNC(113); PROTFUNC(114); 00037 PROTFUNC(115); PROTFUNC(116); PROTFUNC(117); PROTFUNC(118); PROTFUNC(119); 00038 PROTFUNC(120); PROTFUNC(121); PROTFUNC(122); PROTFUNC(123); PROTFUNC(124); 00039 PROTFUNC(125); PROTFUNC(126); PROTFUNC(127); PROTFUNC(128); PROTFUNC(129); 00040 PROTFUNC(130); PROTFUNC(131); PROTFUNC(132); PROTFUNC(133); PROTFUNC(134); 00041 PROTFUNC(135); PROTFUNC(136); PROTFUNC(137); PROTFUNC(138); PROTFUNC(139); 00042 PROTFUNC(140); PROTFUNC(141); PROTFUNC(142); PROTFUNC(143); PROTFUNC(144); 00043 PROTFUNC(145); PROTFUNC(146); PROTFUNC(147); PROTFUNC(148); PROTFUNC(149); 00044 PROTFUNC(150); PROTFUNC(151); PROTFUNC(152); PROTFUNC(153); PROTFUNC(154); 00045 PROTFUNC(155); PROTFUNC(156); PROTFUNC(157); PROTFUNC(158); PROTFUNC(159); 00046 PROTFUNC(160); PROTFUNC(161); PROTFUNC(162); PROTFUNC(163); PROTFUNC(164); 00047 PROTFUNC(165); PROTFUNC(166); PROTFUNC(167); PROTFUNC(168); PROTFUNC(169); 00048 PROTFUNC(170); PROTFUNC(171); PROTFUNC(172); PROTFUNC(173); PROTFUNC(174); 00049 PROTFUNC(175); PROTFUNC(176); PROTFUNC(177); PROTFUNC(178); PROTFUNC(179); 00050 PROTFUNC(180); PROTFUNC(181); PROTFUNC(182); PROTFUNC(183); PROTFUNC(184); 00051 PROTFUNC(185); PROTFUNC(186); PROTFUNC(187); PROTFUNC(188); PROTFUNC(189); 00052 PROTFUNC(190); PROTFUNC(191); PROTFUNC(192); PROTFUNC(193); PROTFUNC(194); 00053 PROTFUNC(195); PROTFUNC(196); PROTFUNC(197); PROTFUNC(198); PROTFUNC(199); 00054 PROTFUNC(200); PROTFUNC(201); PROTFUNC(202); PROTFUNC(203); PROTFUNC(204); 00055 PROTFUNC(205); PROTFUNC(206); PROTFUNC(207); PROTFUNC(208); PROTFUNC(209); 00056 PROTFUNC(210); PROTFUNC(211); PROTFUNC(212); PROTFUNC(213); PROTFUNC(214); 00057 PROTFUNC(215); PROTFUNC(216); PROTFUNC(217); PROTFUNC(218); PROTFUNC(219); 00058 PROTFUNC(220); PROTFUNC(221); PROTFUNC(222); PROTFUNC(223); PROTFUNC(224); 00059 PROTFUNC(225); PROTFUNC(226); PROTFUNC(227); PROTFUNC(228); PROTFUNC(229); 00060 PROTFUNC(230); PROTFUNC(231); PROTFUNC(232); PROTFUNC(233); PROTFUNC(234); 00061 PROTFUNC(235); PROTFUNC(236); PROTFUNC(237); PROTFUNC(238); PROTFUNC(239); 00062 PROTFUNC(240); PROTFUNC(241); PROTFUNC(242); PROTFUNC(243); PROTFUNC(244); 00063 PROTFUNC(245); PROTFUNC(246); PROTFUNC(247); PROTFUNC(248); PROTFUNC(249); 00064 PROTFUNC(250); PROTFUNC(251); PROTFUNC(252); PROTFUNC(253); PROTFUNC(254); 00065 PROTFUNC(255); PROTFUNC(256); PROTFUNC(257); PROTFUNC(258); PROTFUNC(259); 00066 PROTFUNC(260); PROTFUNC(261); PROTFUNC(262); PROTFUNC(263); PROTFUNC(264); 00067 PROTFUNC(265); PROTFUNC(266); PROTFUNC(267); PROTFUNC(268); PROTFUNC(269); 00068 PROTFUNC(270); PROTFUNC(271); PROTFUNC(272); PROTFUNC(273); PROTFUNC(274); 00069 PROTFUNC(275); PROTFUNC(276); PROTFUNC(277); PROTFUNC(278); PROTFUNC(279); 00070 PROTFUNC(280); PROTFUNC(281); PROTFUNC(282); PROTFUNC(283); PROTFUNC(284); 00071 PROTFUNC(285); PROTFUNC(286); PROTFUNC(287); PROTFUNC(288); PROTFUNC(289); 00072 PROTFUNC(290); PROTFUNC(291); PROTFUNC(292); PROTFUNC(293); PROTFUNC(294); 00073 PROTFUNC(295); PROTFUNC(296); PROTFUNC(297); PROTFUNC(298); PROTFUNC(299); 00074 00075 /* Returning int and using volatile to try to prevent 00076 * optimizer from eliminating too much code 00077 */ 00078 00079 #define FUNC(num) \ 00080 int func_##num(void) \ 00081 { \ 00082 int i; \ 00083 volatile int l = 10; \ 00084 volatile int m = 11; \ 00085 volatile int n = 12; \ 00086 \ 00087 for (i=0; i<FUNCTION_LOOP; i++) { \ 00088 l = l + m - n + i; \ 00089 m = l + m - n + i; \ 00090 n = l + m - n + i; \ 00091 l = l + m - n + i; \ 00092 m = l + m - n + i; \ 00093 n = l + m - n + i; \ 00094 l = l + m - n + i; \ 00095 m = l + m - n + i; \ 00096 n = l + m - n + i; \ 00097 l = l + m - n + i; \ 00098 m = l + m - n + i; \ 00099 n = l + m - n + i; \ 00100 l = l + m - n + i; \ 00101 m = l + m - n + i; \ 00102 n = l + m - n + i; \ 00103 l = l + m - n + i; \ 00104 } \ 00105 for (i=0; i<FUNCTION_LOOP; i++) { \ 00106 m = l + m - n + i; \ 00107 l = l + m - n + i; \ 00108 n = l + m - n + i; \ 00109 m = l + m - n + i; \ 00110 m = l + m - n + i; \ 00111 l = l + m - n + i; \ 00112 n = l + m - n + i; \ 00113 m = l + m - n + i; \ 00114 l = l + m - n + i; \ 00115 n = l + m - n + i; \ 00116 m = l + m - n + i; \ 00117 l = l + m - n + i; \ 00118 n = l + m - n + i; \ 00119 } \ 00120 for (i=0; i<FUNCTION_LOOP; i++) { \ 00121 n = l + m - n + i; \ 00122 m = l + m - n + i; \ 00123 l = l + m - n + i; \ 00124 n = l + m - n + i; \ 00125 m = l + m - n + i; \ 00126 l = l + m - n + i; \ 00127 n = l + m - n + i; \ 00128 } \ 00129 for (i=0; i<FUNCTION_LOOP; i++) { \ 00130 l = l + m - n + i; \ 00131 n = l + m - n + i; \ 00132 m = l + m - n + i; \ 00133 l = l + m - n + i; \ 00134 n = l + m - n + i; \ 00135 m = l + m - n + i; \ 00136 l = l + m - n + i; \ 00137 m = l + m - n + i; \ 00138 l = l + m - n + i; \ 00139 n = l + m - n + i; \ 00140 m = l + m - n + i; \ 00141 l = l + m - n + i; \ 00142 n = l + m - n + i; \ 00143 m = l + m - n + i; \ 00144 l = l + m - n + i; \ 00145 m = l + m - n + i; \ 00146 } \ 00147 \ 00148 \ 00149 return l + m + n; \ 00150 } 00151 00152 00153 /* trying to create a process with a fair sized text segment */ 00154 FUNC(0); FUNC(1); FUNC(2); FUNC(3); FUNC(4); 00155 FUNC(5); FUNC(6); FUNC(7); FUNC(8); FUNC(9); 00156 FUNC(10); FUNC(11); FUNC(12); FUNC(13); FUNC(14); 00157 FUNC(15); FUNC(16); FUNC(17); FUNC(18); FUNC(19); 00158 FUNC(20); FUNC(21); FUNC(22); FUNC(23); FUNC(24); 00159 FUNC(25); FUNC(26); FUNC(27); FUNC(28); FUNC(29); 00160 FUNC(30); FUNC(31); FUNC(32); FUNC(33); FUNC(34); 00161 FUNC(35); FUNC(36); FUNC(37); FUNC(38); FUNC(39); 00162 FUNC(40); FUNC(41); FUNC(42); FUNC(43); FUNC(44); 00163 FUNC(45); FUNC(46); FUNC(47); FUNC(48); FUNC(49); 00164 FUNC(50); FUNC(51); FUNC(52); FUNC(53); FUNC(54); 00165 FUNC(55); FUNC(56); FUNC(57); FUNC(58); FUNC(59); 00166 FUNC(60); FUNC(61); FUNC(62); FUNC(63); FUNC(64); 00167 FUNC(65); FUNC(66); FUNC(67); FUNC(68); FUNC(69); 00168 FUNC(70); FUNC(71); FUNC(72); FUNC(73); FUNC(74); 00169 FUNC(75); FUNC(76); FUNC(77); FUNC(78); FUNC(79); 00170 FUNC(80); FUNC(81); FUNC(82); FUNC(83); FUNC(84); 00171 FUNC(85); FUNC(86); FUNC(87); FUNC(88); FUNC(89); 00172 FUNC(90); FUNC(91); FUNC(92); FUNC(93); FUNC(94); 00173 FUNC(95); FUNC(96); FUNC(97); FUNC(98); FUNC(99); 00174 FUNC(100); FUNC(101); FUNC(102); FUNC(103); FUNC(104); 00175 FUNC(105); FUNC(106); FUNC(107); FUNC(108); FUNC(109); 00176 FUNC(110); FUNC(111); FUNC(112); FUNC(113); FUNC(114); 00177 FUNC(115); FUNC(116); FUNC(117); FUNC(118); FUNC(119); 00178 FUNC(120); FUNC(121); FUNC(122); FUNC(123); FUNC(124); 00179 FUNC(125); FUNC(126); FUNC(127); FUNC(128); FUNC(129); 00180 FUNC(130); FUNC(131); FUNC(132); FUNC(133); FUNC(134); 00181 FUNC(135); FUNC(136); FUNC(137); FUNC(138); FUNC(139); 00182 FUNC(140); FUNC(141); FUNC(142); FUNC(143); FUNC(144); 00183 FUNC(145); FUNC(146); FUNC(147); FUNC(148); FUNC(149); 00184 FUNC(150); FUNC(151); FUNC(152); FUNC(153); FUNC(154); 00185 FUNC(155); FUNC(156); FUNC(157); FUNC(158); FUNC(159); 00186 FUNC(160); FUNC(161); FUNC(162); FUNC(163); FUNC(164); 00187 FUNC(165); FUNC(166); FUNC(167); FUNC(168); FUNC(169); 00188 FUNC(170); FUNC(171); FUNC(172); FUNC(173); FUNC(174); 00189 FUNC(175); FUNC(176); FUNC(177); FUNC(178); FUNC(179); 00190 FUNC(180); FUNC(181); FUNC(182); FUNC(183); FUNC(184); 00191 FUNC(185); FUNC(186); FUNC(187); FUNC(188); FUNC(189); 00192 FUNC(190); FUNC(191); FUNC(192); FUNC(193); FUNC(194); 00193 FUNC(195); FUNC(196); FUNC(197); FUNC(198); FUNC(199); 00194 FUNC(200); FUNC(201); FUNC(202); FUNC(203); FUNC(204); 00195 FUNC(205); FUNC(206); FUNC(207); FUNC(208); FUNC(209); 00196 FUNC(210); FUNC(211); FUNC(212); FUNC(213); FUNC(214); 00197 FUNC(215); FUNC(216); FUNC(217); FUNC(218); FUNC(219); 00198 FUNC(220); FUNC(221); FUNC(222); FUNC(223); FUNC(224); 00199 FUNC(225); FUNC(226); FUNC(227); FUNC(228); FUNC(229); 00200 FUNC(230); FUNC(231); FUNC(232); FUNC(233); FUNC(234); 00201 FUNC(235); FUNC(236); FUNC(237); FUNC(238); FUNC(239); 00202 FUNC(240); FUNC(241); FUNC(242); FUNC(243); FUNC(244); 00203 FUNC(245); FUNC(246); FUNC(247); FUNC(248); FUNC(249); 00204 FUNC(250); FUNC(251); FUNC(252); FUNC(253); FUNC(254); 00205 FUNC(255); FUNC(256); FUNC(257); FUNC(258); FUNC(259); 00206 FUNC(260); FUNC(261); FUNC(262); FUNC(263); FUNC(264); 00207 FUNC(265); FUNC(266); FUNC(267); FUNC(268); FUNC(269); 00208 FUNC(270); FUNC(271); FUNC(272); FUNC(273); FUNC(274); 00209 FUNC(275); FUNC(276); FUNC(277); FUNC(278); FUNC(279); 00210 FUNC(280); FUNC(281); FUNC(282); FUNC(283); FUNC(284); 00211 FUNC(285); FUNC(286); FUNC(287); FUNC(288); FUNC(289); 00212 FUNC(290); FUNC(291); FUNC(292); FUNC(293); FUNC(294); 00213 FUNC(295); FUNC(296); FUNC(297); FUNC(298); FUNC(299); 00214 00215 #define CALLFUNC(i) \ 00216 func_##i() 00217 00218 void 00219 call_all(void) 00220 { 00221 CALLFUNC(0); CALLFUNC(1); CALLFUNC(2); CALLFUNC(3); CALLFUNC(4); 00222 CALLFUNC(5); CALLFUNC(6); CALLFUNC(7); CALLFUNC(8); CALLFUNC(9); 00223 CALLFUNC(10); CALLFUNC(11); CALLFUNC(12); CALLFUNC(13); CALLFUNC(14); 00224 CALLFUNC(15); CALLFUNC(16); CALLFUNC(17); CALLFUNC(18); CALLFUNC(19); 00225 CALLFUNC(20); CALLFUNC(21); CALLFUNC(22); CALLFUNC(23); CALLFUNC(24); 00226 CALLFUNC(25); CALLFUNC(26); CALLFUNC(27); CALLFUNC(28); CALLFUNC(29); 00227 CALLFUNC(30); CALLFUNC(31); CALLFUNC(32); CALLFUNC(33); CALLFUNC(34); 00228 CALLFUNC(35); CALLFUNC(36); CALLFUNC(37); CALLFUNC(38); CALLFUNC(39); 00229 CALLFUNC(40); CALLFUNC(41); CALLFUNC(42); CALLFUNC(43); CALLFUNC(44); 00230 CALLFUNC(45); CALLFUNC(46); CALLFUNC(47); CALLFUNC(48); CALLFUNC(49); 00231 CALLFUNC(50); CALLFUNC(51); CALLFUNC(52); CALLFUNC(53); CALLFUNC(54); 00232 CALLFUNC(55); CALLFUNC(56); CALLFUNC(57); CALLFUNC(58); CALLFUNC(59); 00233 CALLFUNC(60); CALLFUNC(61); CALLFUNC(62); CALLFUNC(63); CALLFUNC(64); 00234 CALLFUNC(65); CALLFUNC(66); CALLFUNC(67); CALLFUNC(68); CALLFUNC(69); 00235 CALLFUNC(70); CALLFUNC(71); CALLFUNC(72); CALLFUNC(73); CALLFUNC(74); 00236 CALLFUNC(75); CALLFUNC(76); CALLFUNC(77); CALLFUNC(78); CALLFUNC(79); 00237 CALLFUNC(80); CALLFUNC(81); CALLFUNC(82); CALLFUNC(83); CALLFUNC(84); 00238 CALLFUNC(85); CALLFUNC(86); CALLFUNC(87); CALLFUNC(88); CALLFUNC(89); 00239 CALLFUNC(90); CALLFUNC(91); CALLFUNC(92); CALLFUNC(93); CALLFUNC(94); 00240 CALLFUNC(95); CALLFUNC(96); CALLFUNC(97); CALLFUNC(98); CALLFUNC(99); 00241 CALLFUNC(100); CALLFUNC(101); CALLFUNC(102); CALLFUNC(103); CALLFUNC(104); 00242 CALLFUNC(105); CALLFUNC(106); CALLFUNC(107); CALLFUNC(108); CALLFUNC(109); 00243 CALLFUNC(110); CALLFUNC(111); CALLFUNC(112); CALLFUNC(113); CALLFUNC(114); 00244 CALLFUNC(115); CALLFUNC(116); CALLFUNC(117); CALLFUNC(118); CALLFUNC(119); 00245 CALLFUNC(120); CALLFUNC(121); CALLFUNC(122); CALLFUNC(123); CALLFUNC(124); 00246 CALLFUNC(125); CALLFUNC(126); CALLFUNC(127); CALLFUNC(128); CALLFUNC(129); 00247 CALLFUNC(130); CALLFUNC(131); CALLFUNC(132); CALLFUNC(133); CALLFUNC(134); 00248 CALLFUNC(135); CALLFUNC(136); CALLFUNC(137); CALLFUNC(138); CALLFUNC(139); 00249 CALLFUNC(140); CALLFUNC(141); CALLFUNC(142); CALLFUNC(143); CALLFUNC(144); 00250 CALLFUNC(145); CALLFUNC(146); CALLFUNC(147); CALLFUNC(148); CALLFUNC(149); 00251 CALLFUNC(150); CALLFUNC(151); CALLFUNC(152); CALLFUNC(153); CALLFUNC(154); 00252 CALLFUNC(155); CALLFUNC(156); CALLFUNC(157); CALLFUNC(158); CALLFUNC(159); 00253 CALLFUNC(160); CALLFUNC(161); CALLFUNC(162); CALLFUNC(163); CALLFUNC(164); 00254 CALLFUNC(165); CALLFUNC(166); CALLFUNC(167); CALLFUNC(168); CALLFUNC(169); 00255 CALLFUNC(170); CALLFUNC(171); CALLFUNC(172); CALLFUNC(173); CALLFUNC(174); 00256 CALLFUNC(175); CALLFUNC(176); CALLFUNC(177); CALLFUNC(178); CALLFUNC(179); 00257 CALLFUNC(180); CALLFUNC(181); CALLFUNC(182); CALLFUNC(183); CALLFUNC(184); 00258 CALLFUNC(185); CALLFUNC(186); CALLFUNC(187); CALLFUNC(188); CALLFUNC(189); 00259 CALLFUNC(190); CALLFUNC(191); CALLFUNC(192); CALLFUNC(193); CALLFUNC(194); 00260 CALLFUNC(195); CALLFUNC(196); CALLFUNC(197); CALLFUNC(198); CALLFUNC(199); 00261 CALLFUNC(200); CALLFUNC(201); CALLFUNC(202); CALLFUNC(203); CALLFUNC(204); 00262 CALLFUNC(205); CALLFUNC(206); CALLFUNC(207); CALLFUNC(208); CALLFUNC(209); 00263 CALLFUNC(210); CALLFUNC(211); CALLFUNC(212); CALLFUNC(213); CALLFUNC(214); 00264 CALLFUNC(215); CALLFUNC(216); CALLFUNC(217); CALLFUNC(218); CALLFUNC(219); 00265 CALLFUNC(220); CALLFUNC(221); CALLFUNC(222); CALLFUNC(223); CALLFUNC(224); 00266 CALLFUNC(225); CALLFUNC(226); CALLFUNC(227); CALLFUNC(228); CALLFUNC(229); 00267 CALLFUNC(230); CALLFUNC(231); CALLFUNC(232); CALLFUNC(233); CALLFUNC(234); 00268 CALLFUNC(235); CALLFUNC(236); CALLFUNC(237); CALLFUNC(238); CALLFUNC(239); 00269 CALLFUNC(240); CALLFUNC(241); CALLFUNC(242); CALLFUNC(243); CALLFUNC(244); 00270 CALLFUNC(245); CALLFUNC(246); CALLFUNC(247); CALLFUNC(248); CALLFUNC(249); 00271 CALLFUNC(250); CALLFUNC(251); CALLFUNC(252); CALLFUNC(253); CALLFUNC(254); 00272 CALLFUNC(255); CALLFUNC(256); CALLFUNC(257); CALLFUNC(258); CALLFUNC(259); 00273 CALLFUNC(260); CALLFUNC(261); CALLFUNC(262); CALLFUNC(263); CALLFUNC(264); 00274 CALLFUNC(265); CALLFUNC(266); CALLFUNC(267); CALLFUNC(268); CALLFUNC(269); 00275 CALLFUNC(270); CALLFUNC(271); CALLFUNC(272); CALLFUNC(273); CALLFUNC(274); 00276 CALLFUNC(275); CALLFUNC(276); CALLFUNC(277); CALLFUNC(278); CALLFUNC(279); 00277 CALLFUNC(280); CALLFUNC(281); CALLFUNC(282); CALLFUNC(283); CALLFUNC(284); 00278 CALLFUNC(285); CALLFUNC(286); CALLFUNC(287); CALLFUNC(288); CALLFUNC(289); 00279 CALLFUNC(290); CALLFUNC(291); CALLFUNC(292); CALLFUNC(293); CALLFUNC(294); 00280 CALLFUNC(295); CALLFUNC(296); CALLFUNC(297); CALLFUNC(298); CALLFUNC(299); 00281 } /* call_all */ 00282 00283 void 00284 call_all_loop(int count) 00285 { 00286 int i = 0; 00287 for (i=0; i<count; i++) { 00288 call_all(); 00289 } 00290 }
1.7.6.1
