code: func (s *Service) FireAllTasks(c context.Context) error {
  	cfg := getConfig(c)
  
  	namespaces, err := s.getNamespaces(c, cfg)
  	if err != nil {
  		return err
  	}
  
  	// Probe each namespace in parallel. Each probe function reports its own
  	// errors, so the work pool will never return any non-nil error response.
  	var errCount, taskCount counter
  	_ = parallel.WorkPool(cfg.NumGoroutines, func(ch chan<- func() error) {
  		for _, ns := range namespaces {
  			ns := ns
  			ch <- func() error {
  				// Generate a list of all shards.
  				allShards := make([]taskShard, 0, cfg.TotalShardCount(ns))
  				for i := uint64(0); i < cfg.TotalShardCount(ns); i++ {
  					allShards = append(allShards, taskShard{i, minTS})
  				}
  				s.fireAllTasksForNamespace(c, cfg, ns, allShards, &errCount, &taskCount)
  				return nil
  			}
  		}
  	})
  	if errCount > 0 {
  		logging.Errorf(c, "Encountered %d error(s).", errCount)
  		return errors.New("errors were encountered while probing for tasks")
  	}
  
  	logging.Debugf(c, "Successfully probed %d namespace(s) and fired %d tasks(s).",
  		len(namespaces), taskCount)
  	return err
  }
docs: // FireAllTasks searches for work in all namespaces, and fires off a process
  // task for any shards it finds that have at least one Mutation present to
  // ensure that no work languishes forever. This may not be needed in
  // a constantly-loaded system with good tumble key distribution.