docs: def _load_modules(self, force_refresh=False, notify=False, grains=None, opts=None):
          '''
          Return the functions and the returners loaded up from the loader
          module
          '''
          opt_in = True
          if not opts:
              opts = self.opts
              opt_in = False
          # if this is a *nix system AND modules_max_memory is set, lets enforce
          # a memory limit on module imports
          # this feature ONLY works on *nix like OSs (resource module doesn't work on windows)
          modules_max_memory = False
          if opts.get('modules_max_memory', -1) > 0 and HAS_PSUTIL and HAS_RESOURCE:
              log.debug(
                  'modules_max_memory set, enforcing a maximum of %s',
                  opts['modules_max_memory']
              )
              modules_max_memory = True
              old_mem_limit = resource.getrlimit(resource.RLIMIT_AS)
              rss, vms = psutil.Process(os.getpid()).memory_info()[:2]
              mem_limit = rss + vms + opts['modules_max_memory']
              resource.setrlimit(resource.RLIMIT_AS, (mem_limit, mem_limit))
          elif opts.get('modules_max_memory', -1) > 0:
              if not HAS_PSUTIL:
                  log.error('Unable to enforce modules_max_memory because psutil is missing')
              if not HAS_RESOURCE:
                  log.error('Unable to enforce modules_max_memory because resource is missing')
  
          # This might be a proxy minion
          if hasattr(self, 'proxy'):
              proxy = self.proxy
          else:
              proxy = None
  
          if grains is None:
              opts['grains'] = salt.loader.grains(opts, force_refresh, proxy=proxy)
          self.utils = salt.loader.utils(opts, proxy=proxy)
  
          if opts.get('multimaster', False):
              s_opts = copy.deepcopy(opts)
              functions = salt.loader.minion_mods(s_opts, utils=self.utils, proxy=proxy,
                                                  loaded_base_name=self.loaded_base_name, notify=notify)
          else:
              functions = salt.loader.minion_mods(opts, utils=self.utils, notify=notify, proxy=proxy)
          returners = salt.loader.returners(opts, functions, proxy=proxy)
          errors = {}
          if '_errors' in functions:
              errors = functions['_errors']
              functions.pop('_errors')
  
          # we're done, reset the limits!
          if modules_max_memory is True:
              resource.setrlimit(resource.RLIMIT_AS, old_mem_limit)
  
          executors = salt.loader.executors(opts, functions, proxy=proxy)
  
          if opt_in:
              self.opts = opts
  
          return functions, returners, errors, executors