docs: def create_snapshot(self, description='', compute_total=False):
          """
          Collect current per instance statistics and saves total amount of
          memory associated with the Python process.
  
          If `compute_total` is `True`, the total consumption of all objects
          known to *asizeof* is computed. The latter might be very slow if many
          objects are mapped into memory at the time the snapshot is taken.
          Therefore, `compute_total` is set to `False` by default.
  
          The overhead of the `ClassTracker` structure is also computed.
  
          Snapshots can be taken asynchronously. The function is protected with a
          lock to prevent race conditions.
          """
  
          try:
              # TODO: It is not clear what happens when memory is allocated or
              # released while this function is executed but it will likely lead
              # to inconsistencies. Either pause all other threads or don't size
              # individual objects in asynchronous mode.
              self.snapshot_lock.acquire()
  
              timestamp = _get_time()
  
              sizer = asizeof.Asizer()
              objs = [tobj.ref() for tobj in list(self.objects.values())]
              sizer.exclude_refs(*objs)
  
              # The objects need to be sized in a deterministic order. Sort the
              # objects by its creation date which should at least work for non-parallel
              # execution. The "proper" fix would be to handle shared data separately.
              tracked_objects = list(self.objects.values())
              tracked_objects.sort(key=lambda x: x.birth)
              for tobj in tracked_objects:
                  tobj.track_size(timestamp, sizer)
  
              snapshot = Snapshot()
  
              snapshot.timestamp = timestamp
              snapshot.tracked_total = sizer.total
              if compute_total:
                  snapshot.asizeof_total = asizeof.asizeof(all=True, code=True)
              snapshot.system_total = pympler.process.ProcessMemoryInfo()
              snapshot.desc = str(description)
  
              # Compute overhead of all structures, use sizer to exclude tracked objects(!)
              snapshot.overhead = 0
              if snapshot.tracked_total:
                  snapshot.overhead = sizer.asizeof(self)
                  if snapshot.asizeof_total:
                      snapshot.asizeof_total -= snapshot.overhead
  
              self.snapshots.append(snapshot)
  
          finally:
              self.snapshot_lock.release()