docs: def _get_usage(function, *args):
      """Test if more memory is used after the function has been called.
  
      The function will be invoked twice and only the second measurement will be
      considered. Thus, memory used in initialisation (e.g. loading modules)
      will not be included in the result. The goal is to identify memory leaks
      caused by functions which use more and more memory.
  
      Any arguments next to the function will be passed on to the function
      on invocation.
  
      Note that this function is currently experimental, because it is not
      tested thoroughly and performs poorly.
  
      """
      # The usage of a function is calculated by creating one summary of all
      # objects before the function is invoked and afterwards. These summaries
      # are compared and the diff is returned.
      # This function works in a 2-steps process. Before the actual function is
      # invoked an empty dummy function is measurement to identify the overhead
      # involved in the measuring process. This overhead then is subtracted from
      # the measurement performed on the passed function. The result reflects the
      # actual usage of a function call.
      # Also, a measurement is performed twice, allowing the adjustment to
      # initializing things, e.g. modules
  
      res = None
  
      def _get_summaries(function, *args):
          """Get a 2-tuple containing one summary from before, and one summary
          from after the function has been invoked.
  
          """
          s_before = summary.summarize(get_objects())
          function(*args)
          s_after = summary.summarize(get_objects())
          return (s_before, s_after)
  
      def _get_usage(function, *args):
          """Get the usage of a function call.
          This function is to be used only internally. The 'real' get_usage
          function is a wrapper around _get_usage, but the workload is done
          here.
  
          """
          res = []
          # init before calling
          (s_before, s_after) = _get_summaries(function, *args)
          # ignore all objects used for the measurement
          ignore = []
          if s_before != s_after:
              ignore.append(s_before)
          for row in s_before:
              # ignore refs from summary and frame (loop)
              if len(gc.get_referrers(row)) == 2:
                  ignore.append(row)
              for item in row:
                  # ignore refs from summary and frame (loop)
                  if len(gc.get_referrers(item)) == 2:
                      ignore.append(item)
          for o in ignore:
              s_after = summary._subtract(s_after, o)
          res = summary.get_diff(s_before, s_after)
          return summary._sweep(res)
  
      # calibrate; twice for initialization
      def noop(): pass
      offset = _get_usage(noop)
      offset = _get_usage(noop)
      # perform operation twice to handle objects possibly used in
      # initialisation
      tmp = _get_usage(function, *args)
      tmp = _get_usage(function, *args)
      tmp = summary.get_diff(offset, tmp)
      tmp = summary._sweep(tmp)
      if len(tmp) != 0:
          res = tmp
      return res