/freebsd/sys/vm/ |
H A D | vm_kern.h | ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921
|
H A D | vm_init.c | ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921
|
H A D | vm_kern.c | ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921
|
/freebsd/sys/sys/ |
H A D | imgact.h | ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921
|
/freebsd/sys/kern/ |
H A D | kern_exec.c | ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921 ec492b13 Thu Jan 05 01:44:12 GMT 2017 Mark Johnston <markj@FreeBSD.org> Add a small allocator for exec_map entries.
Upon each execve, we allocate a KVA range for use in copying data to the new image. Pages must be faulted into the range, and when the range is freed, the backing pages are freed and their mappings are destroyed. This is a lot of needless overhead, and the exec_map management becomes a bottleneck when many CPUs are executing execve concurrently. Moreover, the number of available ranges is fixed at 16, which is insufficient on large systems and potentially excessive on 32-bit systems.
The new allocator reduces overhead by making exec_map allocations persistent. When a range is freed, pages backing the range are marked clean and made easy to reclaim. With this change, the exec_map is sized based on the number of CPUs.
Reviewed by: kib MFC after: 1 month Differential Revision: https://reviews.freebsd.org/D8921
|