Movatterモバイル変換

57publicfunction__construct( array $params = [] ) {

58 $this->errorEntry = $this->getErrorEntry();

59 $this->logger = LoggerFactory::getInstance('profiler' );

60 }

66publicfunctionscopedProfileIn( $section ) {

67 $this->profileInInternal( $section );

69returnnewSectionProfileCallback( $this, $section );

70 }

72publicfunctionscopedProfileOut( ScopedCallback &$section ) {

73 $section =null;

74 }

97publicfunctiongetFunctionStats() {

98 $this->collateData();

100if ( is_array( $this->start ) && is_array( $this->end ) ) {

101 $totalCpu = max( $this->end['cpu'] - $this->start['cpu'], 0 );

102 $totalReal = max( $this->end['real'] - $this->start['real'], 0 );

103 $totalMem = max( $this->end['memory'] - $this->start['memory'], 0 );

104 }else {

105 $totalCpu = 0;

106 $totalReal = 0;

107 $totalMem = 0;

108 }

110 $profile = [];

111foreach ( $this->collated as $fname => $data ) {

112 $profile[] = [

113'name' => $fname,

114'calls' => $data['count'],

115'real' => $data['real'] * 1000,

116'%real' => $totalReal ? 100 * $data['real'] / $totalReal : 0,

117'cpu' => $data['cpu'] * 1000,

118'%cpu' => $totalCpu ? 100 * $data['cpu'] / $totalCpu : 0,

119'memory' => $data['memory'],

120'%memory' => $totalMem ? 100 * $data['memory'] / $totalMem : 0,

121'min_real' => 1000 * $data['min_real'],

122'max_real' => 1000 * $data['max_real']

123 ];

124 }

126 $profile[] = [

127'name' =>'-total',

128'calls' => 1,

129'real' => 1000 * $totalReal,

130'%real' => 100,

131'cpu' => 1000 * $totalCpu,

132'%cpu' => 100,

133'memory' => $totalMem,

134'%memory' => 100,

135'min_real' => 1000 * $totalReal,

136'max_real' => 1000 * $totalReal

137 ];

139return $profile;

140 }

145publicfunctionreset() {

146 $this->start =null;

147 $this->end =null;

148 $this->stack = [];

149 $this->workStack = [];

150 $this->collated = [];

151 $this->collateDone =false;

152 }

157protectedfunctiongetZeroEntry() {

158return [

159'cpu' => 0.0,

160'real' => 0.0,

161'memory' => 0,

162'count' => 0,

163'min_real' => 0.0,

164'max_real' => 0.0

165 ];

166 }

171protectedfunctiongetErrorEntry() {

172 $entry = $this->getZeroEntry();

173 $entry['count'] = 1;

174return $entry;

175 }

185protectedfunctionupdateEntry( $name, $elapsedCpu, $elapsedReal, $memChange ) {

186 $entry =& $this->collated[$name];

187if ( !is_array( $entry ) ) {

188 $entry = $this->getZeroEntry();

189 $this->collated[$name] =& $entry;

190 }

191 $entry['cpu'] += $elapsedCpu;

192 $entry['real'] += $elapsedReal;

193 $entry['memory'] += $memChange > 0 ? $memChange : 0;

194 $entry['count']++;

195 $entry['min_real'] = min( $entry['min_real'], $elapsedReal );

196 $entry['max_real'] = max( $entry['max_real'], $elapsedReal );

197 }

204publicfunctionprofileInInternal( $functionname ) {

208 $this->collateDone =false;

210 $cpu = $this->getTime('cpu' );

211 $real = $this->getTime('wall' );

212 $memory = memory_get_usage();

214if ( $this->start ===null ) {

215 $this->start = ['cpu' => $cpu,'real' => $real,'memory' => $memory ];

216 }

218 $this->workStack[] = [

219 $functionname,

220 count( $this->workStack ),

221 $real,

222 $cpu,

223 $memory

224 ];

225 }

232publicfunctionprofileOutInternal( $functionname ) {

233 $item = array_pop( $this->workStack );

234if ( $item ===null ) {

235 $this->logger->error("Profiling error: $functionname" );

236return;

237 }

238 [ $ofname,/* $ocount */, $ortime, $octime, $omem ] = $item;

240if ( $functionname ==='close' ) {

241 $message ="Profile section ended by close(): {$ofname}";

242 $this->logger->error( $message );

243 $this->collated[$message] = $this->errorEntry;

244 $functionname = $ofname;

245 } elseif ( $ofname !== $functionname ) {

246 $message ="Profiling error: in({$ofname}), out($functionname)";

247 $this->logger->error( $message );

248 $this->collated[$message] = $this->errorEntry;

249 }

251 $realTime = $this->getTime('wall' );

252 $cpuTime = $this->getTime('cpu' );

253 $memUsage = memory_get_usage();

255 $elapsedcpu = $cpuTime - $octime;

256 $elapsedreal = $realTime - $ortime;

257 $memchange = $memUsage - $omem;

258 $this->updateEntry( $functionname, $elapsedcpu, $elapsedreal, $memchange );

260 $this->end = [

261'cpu' => $cpuTime,

262'real' => $realTime,

263'memory' => $memUsage

264 ];

265 }

270protectedfunctioncollateData() {

271if ( $this->collateDone ) {

272return;

273 }

274 $this->collateDone =true;

276while ( count( $this->workStack ) ) {

277 $this->profileOutInternal('close' );

278 }

279 }

291protectedfunctiongetTime( $metric ='wall' ) {

292if ( $metric ==='cpu' || $metric ==='user' ) {

293 $ru = getrusage( 0/* RUSAGE_SELF */ );

294 $time = $ru['ru_utime.tv_sec'] + $ru['ru_utime.tv_usec'] / 1e6;

295if ( $metric ==='cpu' ) {

298 $time += $ru['ru_stime.tv_sec'] + $ru['ru_stime.tv_usec'] / 1e6;

299 }

300return $time;

301 }else {

302return microtime(true );

303 }

304 }