Resets the global runtime state of a pants runtime for cleaner forking.

  :param bool reset_subsystem: Whether or not to clean Subsystem global state.
194197
def clean_global_runtime_state(reset_subsystem=False):
  
  if reset_subsystem:
    # Reset subsystem state.
    Subsystem.reset()

  # Reset Goals and Tasks.
  Goal.clear()

  # Reset global plugin state.
  BuildConfigInitializer.reset()
792282
def reset(self):
        
        state = self.sample()
        if state is None:
            # None indicates that a normal env reset should occur
            return self.env.reset()
        else:
            if self.need_xml:
                # reset the simulation from the model if necessary
                state, xml = state
                self.env.reset_from_xml_string(xml)

            if isinstance(state, tuple):
                state = state[0]

            # force simulator state to one from the demo
            self.sim.set_state_from_flattened(state)
            self.sim.forward()

            return self.env._get_observation()
771472
def _reset_state(self):
        
        self._builders = {}
        self._total_data_size = 0
        self._progress_offset = 0
        self._current_progress_fraction = 0
986102
def reset ():
    
    global __generators, __type_to_generators, __generators_for_toolset, __construct_stack
    global __overrides, __active_generators
    global __viable_generators_cache, __viable_source_types_cache
    global __vstg_cached_generators, __vst_cached_types

    __generators = {}
    __type_to_generators = {}
    __generators_for_toolset = {}
    __overrides = {}

    # TODO: can these be global?
    __construct_stack = []
    __viable_generators_cache = {}
    __viable_source_types_cache = {}
    __active_generators = []

    __vstg_cached_generators = []
    __vst_cached_types = []
564868
def default_software_reset_type(self, reset_type):
        
        assert isinstance(reset_type, Target.ResetType)
        assert reset_type in (Target.ResetType.SW_SYSRESETREQ, Target.ResetType.SW_VECTRESET,
                                Target.ResetType.SW_EMULATED)
        self._default_software_reset_type = reset_type
859446
def reset(self):
        
        # Can only reset tasks that are done.
        # One should be able to reset 'Submitted' tasks (sometimes, they are not in the queue
        # and we want to restart them)
        #if self.status != self.S_SUB and self.status < self.S_DONE: return 1

        # Remove output files otherwise the EventParser will think the job is still running
        self.output_file.remove()
        self.log_file.remove()
        self.stderr_file.remove()
        self.start_lockfile.remove()
        self.qerr_file.remove()
        self.qout_file.remove()
        if self.mpiabort_file.exists:
            self.mpiabort_file.remove()

        self.set_status(self.S_INIT, msg="Reset on %s" % time.asctime())
        self.num_restarts = 0
        self.set_qjob(None)

        # Reset finalized flags.
        self.work.finalized = False
        self.flow.finalized = False

        return 0
842070
public static void enableSubsystem(ISubsystem subsystem, boolean enable) {
        if (enable_logging) {
            if (enable) {
                mEnabledSubsystems.add(subsystem);
            } else {
                mEnabledSubsystems.remove(subsystem);
            }
        }
    }
961260
def reset_server(self):
        
        sushy_system = self._get_sushy_system(PROLIANT_SYSTEM_ID)
        try:
            sushy_system.reset_system(sushy.RESET_FORCE_RESTART)
        except sushy.exceptions.SushyError as e:
            msg = (self._('The Redfish controller failed to reset server. '
                          'Error %(error)s') %
                   {'error': str(e)})
            LOG.debug(msg)
            raise exception.IloError(msg)
386487
def reset_component(self, component):
		
		if isinstance(component, str) is True:
			component = WURI.Component(component)
		self.__components[component] = None
1132065
protected void reset() {
		if (this.status == ProcessStatus.STOPPED || this.status == ProcessStatus.COMPLETED) {
			if (this.runOnce) {
				throw new UnsupportedOperationException("This process template can only safely execute once; "
						+ "instantiate a new instance per request");
			}

			this.status = ProcessStatus.RESET;
		}
	}
1100990
def reset(self):
        
        for key in list(self.keys()): self.iterators[key] = _itertools.cycle(self[key])
        return self
572183
public static function resetGlobalState()
    {
        foreach (self::$module_loggers as $logger)
            $logger->removeLogWriters();
        self::$module_loggers = [];
        self::$accept_mode = self::MODE_ACCEPT_MOST_SPECIFIC;
    }
759889
def reset(self):
        
        for _, item in self.iter_items(recursive=True):
            item.reset()
3071
def reset(self):
        
        if self.running:
            raise RuntimeError('paco: executor is still running')

        self.pool.clear()
        self.observer.clear()
        self.semaphore = asyncio.Semaphore(self.limit, loop=self.loop)
101488
private void reset()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "reset");

    if (iInitialised)
    {
      // Reset the ArrayLists associated with this message        
      iTopics.clear();
      iTopicSpaces.clear();
      iTopicSpaceMappings.clear();

      // Create a new message to send to this Neighbour.
      iSubscriptionMessage = createSubscriptionMessage();
    }
    else
    {
      iInitialised = true;
    }

    if (tc.isEntryEnabled())
      SibTr.exit(tc, "reset");
  }
1344389
function globalReset (self) {
    // reset data for all instances
    _.each(global.__immutable_global__, instance => instance.reset())
    // reset internal data
    if (self) {
        global.__immutable_global__ = {}
    }
}
1191445
def reset(self):
        '''
        '''
        for index in range(self.counts_len):
            self.counts[index] = 0
        self.total_count = 0
        self.min_value = sys.maxsize
        self.max_value = 0
        self.start_time_stamp_msec = sys.maxsize
        self.end_time_stamp_msec = 0