def METHOD_NAME(self):
    with log_errors():
        workers = list(self.scheduler.workers.values())
        rmm_total = []
        rmm_used = []
        external_used = []
        gpu_index = []
        y = []
        worker = []
        external_used_x = []
        memory_max = 0
        gpu_total = []
        rmm_memory_text = []
        for idx, ws in enumerate(workers):
            try:
                rmm_metrics = ws.metrics["rmm"]
                gpu_metrics = ws.metrics["gpu"]
                gpu_info = ws.extra["gpu"]
            except KeyError:
                continue
            rmm_total_worker = rmm_metrics["rmm-total"]  # RMM memory only
            rmm_used_worker = rmm_metrics["rmm-used"]
            gpu_total_worker = gpu_info["memory-total"]  # All GPU memory
            gpu_used_worker = gpu_metrics["memory-used"]
            external_used_worker = gpu_used_worker - rmm_total_worker
            rmm_total.append(rmm_total_worker)
            rmm_used.append(rmm_used_worker)
            gpu_total.append(gpu_total_worker)
            external_used.append(external_used_worker)
            external_used_x.append(rmm_total_worker + external_used_worker / 2)
            worker.append(ws.address)
            gpu_index.append(idx)
            y.append(idx)
            memory_max = max(memory_max, gpu_total_worker)
            rmm_memory_text.append(
                "RMM memory used: {}/{}\nTotal GPU memory used: {}/{}".format(
                    format_bytes(rmm_used_worker),
                    format_bytes(rmm_total_worker),
                    format_bytes(gpu_used_worker),
                    format_bytes(gpu_total_worker),
                )
            )
        self.memory_figure.title.text = dedent(
            """\
            RMM Utilization: {} / {}
            GPU Memory: {} / {}
            """.format(
                format_bytes(sum(rmm_used)),
                format_bytes(sum(rmm_total)),
                format_bytes(sum([*rmm_total, *external_used])),
                format_bytes(sum(gpu_total)),
            )
        )
        result = {
            "rmm-total": rmm_total,
            "rmm-used": rmm_used,
            "external-used": external_used,
            "rmm-total-half": [m // 2 for m in rmm_total],
            "rmm-used-half": [m // 2 for m in rmm_used],
            "external-used-x": external_used_x,
            "worker": worker,
            "gpu-index": gpu_index,
            "y": y,
            "escaped_worker": [escape.url_escape(w) for w in worker],
            "rmm_memory_text": rmm_memory_text,
        }
        self.memory_figure.x_range.end = memory_max
        METHOD_NAME(self.source, result)