Starts the timer.
@return void
776483
function start(): void {
        if($this->nativeHrtime) {
            $this->timer = \hrtime(true);
        } elseif($this->hrtime) {
            $this->timer->start();
        } else {
            $this->timer = \microtime(true);
        }
    }
877587
public function resetTimer()
    {
        if (empty($this->timer) === true) {
            $this->timer = time() + $this->maxRuntime;
        }
    }
29721
public function start()
    {
        if (headers_sent() === false) {
            session_start();
            $this->started = true;
            $this->session = &$_SESSION;

            return true;
        }

        return false;
    }
504332
public function start() : void
    {
        if ($this->startTime === null) {
            $this->startTime = $this->clock->getTime();
        }
    }
506529
public function Start()
    {
        foreach($this->symbols->headers as $header_name=>$header_object)
        {
            // Skip disabled headers
            if(!$header_object->enabled)
            {
                $this->RemoveHeader($header_name);
                continue;
            }

            // Generate header file
            $header_content = $this->GenerateHeader($header_name);

            $this->AddHeader($header_name, $header_content);

            // Generate classes header file
            $classes_header_content = $this->GenerateClassesHeader($header_name);

            $this->AddHeader(
                $header_name,
                $classes_header_content,
                "includes/classes"
            );

            // Generate source file
            $source_content = $this->GenerateSource($header_name);

            $this->AddSource($header_name, $source_content);
        }

        $this->GenerateOtherSources();

        $this->GenerateCustomSources();

        $this->GenerateConfigs();
    }
271756
public function start(): void
    {
        // In case Lambda stopped our process (e.g. because of a timeout) we need to make sure PHP-FPM has stopped
        // as well and restart it
        if ($this->isReady()) {
            $this->killExistingFpm();
        }

        if (! is_dir(dirname(self::SOCKET))) {
            mkdir(dirname(self::SOCKET));
        }

        /**
         * --nodaemonize: we want to keep control of the process
         * --force-stderr: force logs to be sent to stderr, which will allow us to send them to CloudWatch
         */
        $this->fpm = new Process(['php-fpm', '--nodaemonize', '--force-stderr', '--fpm-config', $this->configFile]);
        $this->fpm->setTimeout(null);
        $this->fpm->start(function ($type, $output): void {
            // Send any PHP-FPM log to CloudWatch
            echo $output;
        });

        $connection = new UnixDomainSocket(self::SOCKET, 1000, 30000);
        $this->client = new Client($connection);

        $this->waitUntilReady();
    }
1135632
public function start()
    {
        if (!$this->canStart()) {
            return false;
        }

        $this->startTime = microtime(true);

        return $this->setState(self::STATE_STARTED);
    }
1335997
public function start()
    {
        $this->createQueue();

        while (count($this->getChannel()->callbacks)) {
            try {
                $this->getChannel()->wait();
            } catch (\Exception $e) {
                fwrite($this->errOutput, $e->getMessage());
                $this->forceReconnect();

                continue;
            }
        }
        $connection = $this->getChannel()->getConnection();
        $this->getChannel()->close();
        $connection->close();
    }
797166
protected function setTimers()
	{
		if (!$this->has('session.timer.start'))
		{
			$start = time();

			$this->set('session.timer.start', $start);
			$this->set('session.timer.last', $start);
			$this->set('session.timer.now', $start);
		}

		$this->set('session.timer.last', $this->get('session.timer.now'));
		$this->set('session.timer.now', time());

		return true;
	}
1335536
public function start()
    {
        if ($this->isStart) {
            return;
        }

        $this->startAt = time();
        $this->stopAt  = null;
        $this->isStart = true;

        if (extension_loaded('xdebug')) {
            xdebug_disable();
        }

        foreach ($this->onStart as $callable) {
            call_user_func_array($callable, []);
        }

        while ($this->isStart) {
            $this->tick();
        }

        $this->stopAt = time();

        foreach ($this->onStop as $callable) {
            call_user_func_array($callable, []);
        }

        if (extension_loaded('xdebug')) {
            xdebug_enable();
        }
    }
343706
public function start()
    {
        $command = $this->client->createCommand('MONITOR');
        $this->client->executeCommand($command, $this);
    }
293309
public function start()
    {
        session_name($this->name);
        session_set_save_handler(is_null($this->handler)
            ? new \SessionHandler()
            : $this->handler, true);
        if (session_status() == PHP_SESSION_NONE) {
            session_start();
        }
        $this->sessionId = session_id();
        if ($this->security->start()) {
            $this->refresh();
        }
    }
989571
private function __startAutoGC()
    {
        $gcInterval = $this->config->getGCInterval();
        if(null !== $gcInterval)
        {
            $this->timerID = \swoole_timer_tick($gcInterval * 1000, [$this, 'gc']);
        }
    }
184317
public void start()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "start");

    synchronized (this)
    {
      _stopped = false;
    }

    // start all the liveness timers
    _eagerGetTOM.startTimer();
    _slowedGetTOM.startTimer();
    _initialAcceptedTOM.startTimer();
    _acceptedTOM.startTimer();
    _rejectedTOM.startTimer();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "start");
  }
186209
public function run()
    {
        $this->running = true;

        do {
            $hasEvents = $this->tick(true);
        } while ($this->running && $hasEvents);
        $this->running = false;
    }
1358336
public function start()
    {
        if ($collector = end(static::$_collectors)) {
            $collector->add($collector->_driver->stop());
        }
        static::$_collectors[] = $this;
        $this->_driver->start();
        return true;
    }
77847
public function start()
    {
        $checker_checks = [
            'auth' => '',
        ];
        $checker_result = (new Checker($this->dic))->run($checker_checks);
        if (count($checker_result) > 0) {
            $this->response->setData($checker_result);
        } else {
            $this->response->setData((new ActionUpload($this->dic))->run($this->request->files));
        }

        $this->response->send();
    }