Reinitialize the profiling
@param {Boolean} firstStart
503543
function (firstStart) {
            this._startTime = (firstStart) ? Aria._start : new Date();
            if (firstStart) {
                this._logs = [{
                            classpath : "Aria",
                            msg : "Framework initialization",
                            start : Aria._start
                        }, {
                            classpath : "Aria",
                            stop : (new Date()).getTime()
                        }];
                this._nbLogs = 2;
            } else {
                this._logs = [];
                this._nbLogs = 0;
            }

            // map function on JsObject prototype
            ariaCoreJsObject.prototype.$logTimestamp = function (msg, classpath) {
                classpath = classpath ? classpath : this.$classpath;
                aria.utils.Profiling.logTimestamp(classpath, msg);
            };
            ariaCoreJsObject.prototype.$startMeasure = function (msg, classpath) {
                classpath = classpath ? classpath : this.$classpath;
                return aria.utils.Profiling.startMeasure(classpath, msg);
            };
            ariaCoreJsObject.prototype.$stopMeasure = function (id, classpath) {
                classpath = classpath ? classpath : this.$classpath;
                aria.utils.Profiling.stopMeasure(classpath, id);
            };
        }
626674
public static function reset()
    {
        if (empty(self::$initialState)) {
            self::$initialState = get_class_vars(Inflector::class);
            return;
        }
        foreach (self::$initialState as $key => $val) {
            if ($key != 'initialState') {
                self::${$key} = $val;
            }
        }
        self::$cache = [];
    }
372067
function setInitialState(ret) {
    
    var e, r;
    
    // Before resetting, keep a copy of args
    if (ret) {
      e = (errored ? errors : null);
      r = results;
    }
    
    // Reset runtime vars to their default state
    counter = 0;
    errored = false;
    errors = [];
    results = [];
    
    // Flush stack on first run or when config.flush is true
    if (stack == null || config.flush) stack = [];
    
    // Return prepared arguments
    if (ret) return [e, r];

  }
944476
protected void cleanStart() {
        File workareaFile = bootProps.getWorkareaFile(null);

        // If we're clean starting, remove all files from the working directory;
        // Note: do not reverse the checks in the following if(); we need to call hasServiceBeenApplied each time
        if (ServiceFingerprint.hasServiceBeenApplied(bootProps.getInstallRoot(), workareaFile) || bootProps.checkCleanStart()) {
            // Must clean the static data from the ServiceFinterprint class; otherwise the stale data will be persisted.
            ServiceFingerprint.clear();
            KernelUtils.cleanStart(workareaFile);

            // clean up / remove various "clean" parameters
            // storage area has already been wiped..
            bootProps.remove(BootstrapConstants.INITPROP_OSGI_CLEAN);
            bootProps.remove(BootstrapConstants.OSGI_CLEAN);

        }
    }
641285
public void init() {
        // load the filter mappings (copy of the list in case add is called while we iterate)
        List fMappings = new ArrayList(webAppConfig.getFilterMappings());

        // if the list isn't empty, show that this web app has filters
        if (!fMappings.isEmpty()) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
                logger.logp(Level.FINE, CLASS_NAME, "init", "filter mappings at init time ->" + fMappings);

            _filtersDefined = true;

            // add the filter mappings to the uri or servlet mapping lists
            Iterator iter = fMappings.iterator();

            while (iter.hasNext()) {
                FilterMapping fMapping = (FilterMapping) iter.next();

                addFilterMapping(fMapping);

                //PK86553 - start
                if (WCCustomProperties.INVOKE_FILTER_INIT_AT_START_UP){
                    String filterName = fMapping.getFilterConfig().getFilterName();
                    if (_filterWrappers.get(filterName) == null){
                        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
                            logger.logp(Level.FINE, CLASS_NAME,"init", "load filter init at startup, filter ->"+ filterName);
                        try{
                            loadFilter(filterName);
                        }
                        catch (Throwable th) {
                            //logger.logp(Level.FINE, CLASS_NAME, "init", "Can not initialize filter ["+filterName+"] at startup.");//596191
                            LoggerHelper.logParamsAndException(logger, Level.SEVERE, CLASS_NAME,"init", "init.exception.thrown.by.filter.at.startup", new Object[]{filterName} , th );

                        }
                    }
                }
                //PK86553 - end
            }
        } else if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
            logger.logp(Level.FINE, CLASS_NAME, "init", "no filter mappings at init time");
        }

    }
17633
function () {
    ++this.count;
    if (this.t0 === null) {
      this.start();
      return;
    }
    var elapsed = this._elapsed();
    if (elapsed > 1) {
      Profiler.new_value(this.name, this.count);
      this.count = 0;
      this.start();
    }
  }
126189
public void     start(boolean buildInitial) throws Exception
    {
        Preconditions.checkState(state.compareAndSet(State.LATENT, State.STARTED), "Cannot be started more than once");

        client.getConnectionStateListenable().addListener(connectionStateListener);

        if ( buildInitial )
        {
            client.checkExists().creatingParentContainersIfNeeded().forPath(path);
            internalRebuild();
        }
        reset();
    }
111774
private void updateDStartsInf(BitSet watchHosts) throws ContradictionException {

        for (int idx = 0; idx < vInSize.get(); idx++) {
            int i = vIn.quickGet(idx);
            if (!dStarts[i].isInstantiated() && !associatedToCSliceOnCurrentNode(i)) {

                int lastT = -1;
                for (int x = sortedMinProfile.length - 1; x >= 0; x--) {
                    int t = sortedMinProfile[x];
                    if (t <= dStarts[i].getLB()) {
                        break;
                    }
                    int prevT = sortedMinProfile[x - 1];
                    if (t <= dStarts[i].getUB()
                            && exceedCapacity(profilesMin, prevT, dUsages[i])) {
                        lastT = t;
                        break;
                    }
                }
                if (dStarts[i].updateLowerBound(Math.max(lastT, early.getLB()), aCause) && associateCTask[i] != NO_ASSOCIATIONS && dStarts[i].isInstantiated()) {
                    watchHosts.set(cHosters[associateCTask[i]].getValue());
                }
            }
        }
    }
71378
public void reset() {
        firstPointer = null;
        nextLoadPointer = null;
        nextUnloadPointer = null;
        firstCutpointPointer = null;
        mode = MODE_NORMAL;
    }
39591
function containerRefreshStart(index) {
    previousOrParentNode = loadElement(index);
    ngDevMode && assertNodeType(previousOrParentNode, 0 /* Container */);
    isParent = true;
    previousOrParentNode.data[ACTIVE_INDEX] = 0;
    if (!checkNoChangesMode) {
        // We need to execute init hooks here so ngOnInit hooks are called in top level views
        // before they are called in embedded views (for backwards compatibility).
        executeInitHooks(viewData, tView, creationMode);
    }
}
684911
private void lazyInit() {

    if (mStartSpace != null) {
      return;
    }

    Map<String, Integer> mStartSpace = new HashMap<>();
    Map<String, Integer> mStartNoSpace = new HashMap<>();
    Map<String, String> mFull = new HashMap<>();

    try (InputStream stream = JLanguageTool.getDataBroker().getFromResourceDirAsStream(filename)) {
      List<String> posTokens = loadWords(stream);
      for (String posToken : posTokens) {
        String[] tokenAndTag = posToken.split("\t");
        if (tokenAndTag.length != 2) {
          throw new RuntimeException("Invalid format in " + filename + ": '" + posToken + "', expected two tab-separated parts");
        }
        boolean containsSpace = tokenAndTag[0].indexOf(' ') > 0;
        String firstToken;
        String[] firstTokens;
        if (!containsSpace) {
          firstTokens = new String[tokenAndTag[0].length()];
          firstToken = tokenAndTag[0].substring(0, 1);
          for (int i = 1; i < tokenAndTag[0].length(); i++) {
            firstTokens[i] = tokenAndTag[0].substring(i - 1, i);
          }
          if (mStartNoSpace.containsKey(firstToken)) {
            if (mStartNoSpace.get(firstToken) < firstTokens.length) {
              mStartNoSpace.put(firstToken, firstTokens.length);
            }
          } else {
            mStartNoSpace.put(firstToken, firstTokens.length);
          }
        } else {
          firstTokens = tokenAndTag[0].split(" ");
          firstToken = firstTokens[0];

          if (mStartSpace.containsKey(firstToken)) {
            if (mStartSpace.get(firstToken) < firstTokens.length) {
              mStartSpace.put(firstToken, firstTokens.length);
            }
          } else {
            mStartSpace.put(firstToken, firstTokens.length);
          }
        }
        mFull.put(tokenAndTag[0], tokenAndTag[1]);
      }
    } catch (IOException e) {
      throw new RuntimeException(e);
    }

    this.mStartSpace = mStartSpace;
    this.mStartNoSpace = mStartNoSpace;
    this.mFull = mFull;
  }
258947
static Matcher removeRepeatedStart(Matcher matcher) {
    if (matcher instanceof ZeroOrMoreMatcher) {
      ZeroOrMoreMatcher zm = matcher.as();
      if (zm.repeated() instanceof StartMatcher) {
        return zm.next();
      }
    }
    return matcher;
  }
270751
private static final void setInit(final CClassLoader loader) {
		loader.booInit = true;

		for (final Iterator it = loader.getChildLoader(); it.hasNext();) {
			final Map.Entry entry = (Map.Entry) it.next();
			CClassLoader.setInit((CClassLoader) entry.getValue());
		}
	}
1129927
function internalStart(test) {

  	// If semaphore is non-numeric, throw error
  	if (isNaN(test.semaphore)) {
  		test.semaphore = 0;

  		pushFailure("Invalid value on test.semaphore", sourceFromStacktrace(2));
  		return;
  	}

  	// Don't start until equal number of stop-calls
  	if (test.semaphore > 0) {
  		return;
  	}

  	// Throw an Error if start is called more often than stop
  	if (test.semaphore < 0) {
  		test.semaphore = 0;

  		pushFailure("Tried to restart test while already started (test's semaphore was 0 already)", sourceFromStacktrace(2));
  		return;
  	}

  	// Add a slight delay to allow more assertions etc.
  	if (defined.setTimeout) {
  		if (config.timeout) {
  			clearTimeout(config.timeout);
  		}
  		config.timeout = setTimeout(function () {
  			if (test.semaphore > 0) {
  				return;
  			}

  			if (config.timeout) {
  				clearTimeout(config.timeout);
  			}

  			begin();
  		}, 13);
  	} else {
  		begin();
  	}
  }
1224846
private boolean onFirstStep() {
        if (!mFirstStepDone) {
            Log.d(TAG, "onFirstStep()");
            mFirstStepDone = true;
            float yaw = getMainCameraRigYaw();
            Log.d(TAG, "Update frontFacingRotation at start: %f", yaw);
            updateFrontFacingRotation(yaw);

            // Now we will do our first layout
            mSceneRootWidget.onFirstStep();

            return true;
        }

        return false;
    }
1179714
public void reinitialize ()
  {
    m_aRWLock.writeLocked ( () -> {
      m_aMimeTypeContents.clear ();
      _registerDefaultMimeTypeContents ();
    });

    if (LOGGER.isDebugEnabled ())
      LOGGER.debug ("Reinitialized " + MimeTypeDeterminator.class.getName ());
  }
240936
function () {
				BaseController.prototype.onInit.call(this);

				// manually call the handler once at startup as device API won't do this for us
				this._onOrientationChange({
					landscape: Device.orientation.landscape
				});

				this.handleDocumentationDisclaimer();
			}