Create a set of pids of selected processes.
        Search for search_string

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