Merge changes Ia7ecd0e1,I33982473

from __future__ import print_function

import array

import common

import copy

import functools

import heapq

import subprocess

import sys

import threading

from collections import deque, OrderedDict

from hashlib import sha1

import common

from rangelib import RangeSet

    Returns:

      A boolean result.

    """

    if (self.disable_imgdiff or not self.FileTypeSupportedByImgdiff(name)):

    if self.disable_imgdiff or not self.FileTypeSupportedByImgdiff(name):

      return False

    if not tgt_ranges.monotonic or not src_ranges.monotonic:

      #   <# blocks> - <stash refs...>

      size = xf.src_ranges.size()

      src_str = [str(size)]

      src_str_buffer = [str(size)]

      unstashed_src_ranges = xf.src_ranges

      mapped_stashes = []

        sr = xf.src_ranges.map_within(sr)

        mapped_stashes.append(sr)

        assert sh in stashes

        src_str.append("%s:%s" % (sh, sr.to_string_raw()))

        src_str_buffer.append("%s:%s" % (sh, sr.to_string_raw()))

        stashes[sh] -= 1

        if stashes[sh] == 0:

          free_string.append("free %s\n" % (sh,))

          stashes.pop(sh)

      if unstashed_src_ranges:

        src_str.insert(1, unstashed_src_ranges.to_string_raw())

        src_str_buffer.insert(1, unstashed_src_ranges.to_string_raw())

        if xf.use_stash:

          mapped_unstashed = xf.src_ranges.map_within(unstashed_src_ranges)

          src_str.insert(2, mapped_unstashed.to_string_raw())

          src_str_buffer.insert(2, mapped_unstashed.to_string_raw())

          mapped_stashes.append(mapped_unstashed)

          self.AssertPartition(RangeSet(data=(0, size)), mapped_stashes)

      else:

        src_str.insert(1, "-")

        src_str_buffer.insert(1, "-")

        self.AssertPartition(RangeSet(data=(0, size)), mapped_stashes)

      src_str = " ".join(src_str)

      src_str = " ".join(src_str_buffer)

      # version 3+:

      #   zero <rangeset>

      patches = [None] * diff_total

      error_messages = []

      warning_messages = []

      if sys.stdout.isatty():

        global diff_done

        diff_done = 0

      # Using multiprocessing doesn't give additional benefits, due to the

      # pattern of the code. The diffing work is done by subprocess.call, which

            if not diff_queue:

              return

            xf_index, imgdiff, patch_index = diff_queue.pop()

            xf = self.transfers[xf_index]

            if sys.stdout.isatty():

              diff_left = len(diff_queue)

              progress = (diff_total - diff_left) * 100 / diff_total

              # '\033[K' is to clear to EOL.

              print(' [%3d%%] %s\033[K' % (progress, xf.tgt_name), end='\r')

              sys.stdout.flush()

          patch = xf.patch

          if not patch:

            src_ranges = xf.src_ranges

          with lock:

            patches[patch_index] = (xf_index, patch)

            if sys.stdout.isatty():

              global diff_done

              diff_done += 1

              progress = diff_done * 100 / diff_total

              # '\033[K' is to clear to EOL.

              print(' [%d%%] %s\033[K' % (progress, xf.tgt_name), end='\r')

              sys.stdout.flush()

      threads = [threading.Thread(target=diff_worker)

                 for _ in range(self.threads)]

      while sinks:

        new_sinks = OrderedDict()

        for u in sinks:

          if u not in G: continue

          if u not in G:

            continue

          s2.appendleft(u)

          del G[u]

          for iu in u.incoming:

      while sources:

        new_sources = OrderedDict()

        for u in sources:

          if u not in G: continue

          if u not in G:

            continue

          s1.append(u)

          del G[u]

          for iu in u.outgoing:

              new_sources[iu] = None

        sources = new_sources

      if not G: break

      if not G:

        break

      # Find the "best" vertex to put next.  "Best" is the one that

      # maximizes the net difference in source blocks saved we get by

      intersections = OrderedDict()

      for s, e in a.tgt_ranges:

        for i in range(s, e):

          if i >= len(source_ranges): break

          if i >= len(source_ranges):

            break

          # Add all the Transfers in source_ranges[i] to the (ordered) set.

          if source_ranges[i] is not None:

            for j in source_ranges[i]:

              intersections[j] = None

      for b in intersections:

        if a is b: continue

        if a is b:

          continue

        # If the blocks written by A are read by B, then B needs to go before A.

        i = a.tgt_ranges.intersect(b.src_ranges)

        if tgt_changed < tgt_size * crop_threshold:

          assert tgt_changed + tgt_skipped.size() == tgt_size

          print('%10d %10d (%6.2f%%) %s' % (tgt_skipped.size(), tgt_size,

          print('%10d %10d (%6.2f%%) %s' % (

              tgt_skipped.size(), tgt_size,

              tgt_skipped.size() * 100.0 / tgt_size, tgt_name))

          AddSplitTransfers(

              "%s-skipped" % (tgt_name,),