docs: def find_pids(self, name, search_string, exact_match, ignore_ad=True):
          """
          Create a set of pids of selected processes.
          Search for search_string
          """
          if not self.should_refresh_pid_cache(name):
              return self.pid_cache[name]
  
          ad_error_logger = self.log.debug
          if not ignore_ad:
              ad_error_logger = self.log.error
  
          refresh_ad_cache = self.should_refresh_ad_cache(name)
  
          matching_pids = set()
  
          for proc in psutil.process_iter():
              # Skip access denied processes
              if not refresh_ad_cache and proc.pid in self.ad_cache:
                  continue
  
              found = False
              for string in search_string:
                  try:
                      # FIXME 8.x: All has been deprecated
                      # from the doc, should be removed
                      if string == 'All':
                          found = True
                      if exact_match:
                          if os.name == 'nt':
                              if proc.name().lower() == string.lower():
                                  found = True
                          else:
                              if proc.name() == string:
                                  found = True
  
                      else:
                          cmdline = proc.cmdline()
                          if os.name == 'nt':
                              lstring = string.lower()
                              if re.search(lstring, ' '.join(cmdline).lower()):
                                  found = True
                          else:
                              if re.search(string, ' '.join(cmdline)):
                                  found = True
                  except psutil.NoSuchProcess:
                      self.log.warning('Process disappeared while scanning')
                  except psutil.AccessDenied as e:
                      ad_error_logger('Access denied to process with PID {}'.format(proc.pid))
                      ad_error_logger('Error: {}'.format(e))
                      if refresh_ad_cache:
                          self.ad_cache.add(proc.pid)
                      if not ignore_ad:
                          raise
                  else:
                      if refresh_ad_cache:
                          self.ad_cache.discard(proc.pid)
                      if found:
                          matching_pids.add(proc.pid)
                          break
  
          self.pid_cache[name] = matching_pids
          self.last_pid_cache_ts[name] = time.time()
          if refresh_ad_cache:
              self.last_ad_cache_ts[name] = time.time()
          return matching_pids