docs: def _run(self):
          # type: (SyncCopy) -> None
          """Execute SyncCopy
          :param SyncCopy self: this
          """
          # mark start
          self._start_time = blobxfer.util.datetime_now()
          logger.info('blobxfer start time: {0}'.format(self._start_time))
          # initialize resume db if specified
          if self._general_options.resume_file is not None:
              self._resume = blobxfer.operations.resume.SyncCopyResumeManager(
                  self._general_options.resume_file)
          # initialize download threads
          self._initialize_transfer_threads()
          # iterate through source paths to download
          processed_files = 0
          for src_ase, dst_ase in self._bind_sources_to_destination():
              processed_files += 1
              if self._general_options.dry_run:
                  logger.info('[DRY RUN] synccopy: {} -> {}'.format(
                      src_ase.path, dst_ase.path))
              else:
                  # add transfer to set
                  with self._transfer_lock:
                      self._transfer_set.add(
                          blobxfer.operations.synccopy.SyncCopy.
                          create_unique_transfer_operation_id(src_ase, dst_ase))
                      self._synccopy_total += 1
                      self._synccopy_bytes_total += src_ase.size
                      if blobxfer.util.is_not_empty(dst_ase.replica_targets):
                          self._synccopy_bytes_total += (
                              len(dst_ase.replica_targets) * src_ase.size
                          )
                  self._add_to_transfer_queue(src_ase, dst_ase)
          # set remote files processed
          with self._transfer_lock:
              self._all_remote_files_processed = True
              synccopy_size_mib = (
                  self._synccopy_bytes_total / blobxfer.util.MEGABYTE
              )
              logger.debug(
                  ('{0} remote files to sync, waiting for copy '
                   'completion of approx. {1:.4f} MiB').format(
                       processed_files, synccopy_size_mib))
          del processed_files
          # wait for downloads to complete
          self._wait_for_transfer_threads(terminate=False)
          end_time = blobxfer.util.datetime_now()
          # update progress bar
          self._update_progress_bar()
          # check for exceptions
          if len(self._exceptions) > 0:
              logger.error('exceptions encountered while downloading')
              # raise the first one
              raise self._exceptions[0]
          # check for mismatches
          if (self._synccopy_sofar != self._synccopy_total or
                  self._synccopy_bytes_sofar != self._synccopy_bytes_total):
              raise RuntimeError(
                  'copy mismatch: [count={}/{} bytes={}/{}]'.format(
                      self._synccopy_sofar, self._synccopy_total,
                      self._synccopy_bytes_sofar, self._synccopy_bytes_total))
          # delete all remaining local files not accounted for if
          # delete extraneous enabled
          self._delete_extraneous_files()
          # delete resume file if we've gotten this far
          if self._resume is not None:
              self._resume.delete()
          # output throughput
          if self._synccopy_start_time is not None:
              dltime = (end_time - self._synccopy_start_time).total_seconds()
              synccopy_size_mib = (
                  (self._synccopy_bytes_total << 1) / blobxfer.util.MEGABYTE
              )
              dlmibspeed = synccopy_size_mib / dltime
              logger.info(
                  ('elapsed copy time and throughput of {0:.4f} '
                   'GiB: {1:.3f} sec, {2:.4f} Mbps ({3:.3f} MiB/sec)').format(
                       synccopy_size_mib / 1024, dltime, dlmibspeed * 8,
                       dlmibspeed))
          end_time = blobxfer.util.datetime_now()
          logger.info('blobxfer end time: {0} (elapsed: {1:.3f} sec)'.format(
              end_time, (end_time - self._start_time).total_seconds()))