t_uvm_physseg_load.c revision 1.2
1 /* $NetBSD: t_uvm_physseg_load.c,v 1.2 2016/12/22 08:15:20 cherry Exp $ */ 2 3 /*- 4 * Copyright (c) 2015, 2016 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Santhosh N. Raju <santhosh.raju (at) gmail.com> and 9 * by Cherry G. Mathew 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __RCSID("$NetBSD: t_uvm_physseg_load.c,v 1.2 2016/12/22 08:15:20 cherry Exp $"); 35 36 /* 37 * If this line is commented out tests related touvm_physseg_get_pmseg() 38 * wont run. 39 * 40 * Have a look at machine/uvm_physseg.h for more details. 41 */ 42 #define __HAVE_PMAP_PHYSSEG 43 44 /* 45 * This is a dummy struct used for testing purposes 46 * 47 * In reality this struct would exist in the MD part of the code residing in 48 * machines/vmparam.h 49 */ 50 51 #ifdef __HAVE_PMAP_PHYSSEG 52 struct pmap_physseg { 53 int dummy_variable; /* Dummy variable use for testing */ 54 }; 55 #endif 56 57 /* Testing API - assumes userland */ 58 /* Provide Kernel API equivalents */ 59 #include <assert.h> 60 #include <stdbool.h> 61 #include <string.h> /* memset(3) et. al */ 62 #include <stdio.h> /* printf(3) */ 63 #include <stdlib.h> /* malloc(3) */ 64 #include <stdarg.h> 65 #include <stddef.h> 66 #include <time.h> 67 68 #define PRIxPADDR "lx" 69 #define PRIxPSIZE "lx" 70 #define PRIuPSIZE "lu" 71 #define PRIxVADDR "lx" 72 #define PRIxVSIZE "lx" 73 #define PRIuVSIZE "lu" 74 75 #define UVM_HOTPLUG /* Enable hotplug with rbtree. */ 76 #define PMAP_STEAL_MEMORY 77 #define DEBUG /* Enable debug functionality. */ 78 79 typedef unsigned long vaddr_t; 80 typedef unsigned long paddr_t; 81 typedef unsigned long psize_t; 82 typedef unsigned long vsize_t; 83 84 #include <uvm/uvm_physseg.h> 85 #include <uvm/uvm_page.h> 86 87 #ifndef DIAGNOSTIC 88 #define KASSERTMSG(e, msg, ...) /* NOTHING */ 89 #define KASSERT(e) /* NOTHING */ 90 #else 91 #define KASSERT(a) assert(a) 92 #define KASSERTMSG(exp, ...) printf(__VA_ARGS__); assert((exp)) 93 #endif 94 95 #define VM_PHYSSEG_STRAT VM_PSTRAT_BSEARCH 96 97 #define VM_NFREELIST 4 98 #define VM_FREELIST_DEFAULT 0 99 #define VM_FREELIST_FIRST16 3 100 #define VM_FREELIST_FIRST1G 2 101 #define VM_FREELIST_FIRST4G 1 102 103 /* 104 * Used in tests when Array implementation is tested 105 */ 106 #if !defined(VM_PHYSSEG_MAX) 107 #define VM_PHYSSEG_MAX 32 108 #endif 109 110 #define PAGE_SIZE 4096 111 #define PAGE_SHIFT 12 112 #define atop(x) (((paddr_t)(x)) >> PAGE_SHIFT) 113 114 #define mutex_enter(l) 115 #define mutex_exit(l) 116 117 #define _SYS_KMEM_H_ /* Disallow the real kmem API (see below) */ 118 /* free(p) XXX: pgs management need more thought */ 119 #define kmem_alloc(size, flags) malloc(size) 120 #define kmem_zalloc(size, flags) malloc(size) 121 #define kmem_free(p, size) free(p) 122 123 psize_t physmem; 124 125 struct uvmexp uvmexp; /* decl */ 126 127 /* 128 * uvm structure borrowed from uvm.h 129 * 130 * Remember this is a dummy structure used within the ATF Tests and 131 * uses only necessary fields from the original uvm struct. 132 * See uvm/uvm.h for the full struct. 133 */ 134 135 struct uvm { 136 /* vm_page related parameters */ 137 138 bool page_init_done; /* TRUE if uvm_page_init() finished */ 139 } uvm; 140 141 static void 142 panic(const char *fmt, ...) 143 { 144 va_list ap; 145 146 va_start(ap, fmt); 147 vprintf(fmt, ap); 148 printf("\n"); 149 va_end(ap); 150 KASSERT(false); 151 152 /*NOTREACHED*/ 153 } 154 155 static void 156 uvm_pagefree(struct vm_page *pg) 157 { 158 return; 159 } 160 161 #if defined(UVM_HOTPLUG) 162 static void 163 uvmpdpol_reinit(void) 164 { 165 return; 166 } 167 #endif /* UVM_HOTPLUG */ 168 169 /* end - Provide Kernel API equivalents */ 170 171 #include "uvm/uvm_physseg.c" 172 173 #include <atf-c.h> 174 175 #define ONE_MEGABYTE 1024 * 1024 176 177 /* Sample Page Frame Numbers */ 178 #define VALID_START_PFN_1 atop(0) 179 #define VALID_END_PFN_1 atop(ONE_MEGABYTE) 180 #define VALID_AVAIL_START_PFN_1 atop(0) 181 #define VALID_AVAIL_END_PFN_1 atop(ONE_MEGABYTE) 182 183 #define VALID_START_PFN_2 atop(ONE_MEGABYTE + 1) 184 #define VALID_END_PFN_2 atop(ONE_MEGABYTE * 2) 185 #define VALID_AVAIL_START_PFN_2 atop(ONE_MEGABYTE + 1) 186 #define VALID_AVAIL_END_PFN_2 atop(ONE_MEGABYTE * 2) 187 188 #define VALID_START_PFN_3 atop((ONE_MEGABYTE * 2) + 1) 189 #define VALID_END_PFN_3 atop(ONE_MEGABYTE * 3) 190 #define VALID_AVAIL_START_PFN_3 atop((ONE_MEGABYTE * 2) + 1) 191 #define VALID_AVAIL_END_PFN_3 atop(ONE_MEGABYTE * 3) 192 193 #define VALID_START_PFN_4 atop(ONE_MEGABYTE + 1) 194 #define VALID_END_PFN_4 atop(ONE_MEGABYTE * 128) 195 #define VALID_AVAIL_START_PFN_4 atop(ONE_MEGABYTE + 1) 196 #define VALID_AVAIL_END_PFN_4 atop(ONE_MEGABYTE * 128) 197 198 #define VALID_START_PFN_5 atop(ONE_MEGABYTE + 1) 199 #define VALID_END_PFN_5 atop(ONE_MEGABYTE * 256) 200 #define VALID_AVAIL_START_PFN_5 atop(ONE_MEGABYTE + 1) 201 #define VALID_AVAIL_END_PFN_5 atop(ONE_MEGABYTE * 256) 202 203 /* 204 * Total number of pages (of 4K size each) should be 256 for 1MB of memory. 205 */ 206 #define PAGE_COUNT_1M 256 207 208 /* 209 * The number of Page Frames to allot per segment 210 */ 211 #define PF_STEP 8 212 213 /* 214 * A debug fucntion to print the content of upm. 215 */ 216 static inline void 217 uvm_physseg_dump_seg(uvm_physseg_t upm) 218 { 219 #if defined(DEBUG) 220 printf("%s: seg->start == %ld\n", __func__, 221 uvm_physseg_get_start(upm)); 222 printf("%s: seg->end == %ld\n", __func__, 223 uvm_physseg_get_end(upm)); 224 printf("%s: seg->avail_start == %ld\n", __func__, 225 uvm_physseg_get_avail_start(upm)); 226 printf("%s: seg->avail_end == %ld\n", __func__, 227 uvm_physseg_get_avail_end(upm)); 228 229 printf("====\n\n"); 230 #else 231 return; 232 #endif /* DEBUG */ 233 } 234 235 /* 236 * Private accessor that gets the value of vm_physmem.nentries 237 */ 238 static int 239 uvm_physseg_get_entries(void) 240 { 241 #if defined(UVM_HOTPLUG) 242 return uvm_physseg_graph.nentries; 243 #else 244 return vm_nphysmem; 245 #endif /* UVM_HOTPLUG */ 246 } 247 248 /* 249 * Note: This function replicates verbatim what happens in 250 * uvm_page.c:uvm_page_init(). 251 * 252 * Please track any changes that happen there. 253 */ 254 static void 255 uvm_page_init_fake(struct vm_page *pagearray, psize_t pagecount) 256 { 257 uvm_physseg_t bank; 258 size_t n; 259 260 for (bank = uvm_physseg_get_first(), 261 uvm_physseg_seg_chomp_slab(bank, pagearray, pagecount); 262 uvm_physseg_valid_p(bank); 263 bank = uvm_physseg_get_next(bank)) { 264 265 n = uvm_physseg_get_end(bank) - uvm_physseg_get_start(bank); 266 uvm_physseg_seg_alloc_from_slab(bank, n); 267 uvm_physseg_init_seg(bank, pagearray); 268 269 /* set up page array pointers */ 270 pagearray += n; 271 pagecount -= n; 272 } 273 274 uvm.page_init_done = true; 275 } 276 277 /* 278 * PHYS_TO_VM_PAGE: find vm_page for a PA. used by MI code to get vm_pages 279 * back from an I/O mapping (ugh!). used in some MD code as well. 280 */ 281 static struct vm_page * 282 uvm_phys_to_vm_page(paddr_t pa) 283 { 284 paddr_t pf = atop(pa); 285 paddr_t off; 286 uvm_physseg_t psi; 287 288 psi = uvm_physseg_find(pf, &off); 289 if (psi != UVM_PHYSSEG_TYPE_INVALID) 290 return uvm_physseg_get_pg(psi, off); 291 return(NULL); 292 } 293 294 //static paddr_t 295 //uvm_vm_page_to_phys(const struct vm_page *pg) 296 //{ 297 // 298 // return pg->phys_addr; 299 //} 300 301 /* 302 * XXX: To do, write control test cases for uvm_vm_page_to_phys(). 303 */ 304 305 /* #define VM_PAGE_TO_PHYS(entry) uvm_vm_page_to_phys(entry) */ 306 307 #define PHYS_TO_VM_PAGE(pa) uvm_phys_to_vm_page(pa) 308 309 /* 310 * Test Fixture SetUp(). 311 */ 312 static void 313 setup(void) 314 { 315 /* Prerequisites for running certain calls in uvm_physseg */ 316 uvmexp.pagesize = PAGE_SIZE; 317 uvmexp.npages = 0; 318 uvm.page_init_done = false; 319 uvm_physseg_init(); 320 } 321 322 ATF_TC(uvm_physseg_100); 323 ATF_TC_HEAD(uvm_physseg_100, tc) 324 { 325 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 326 100 calls, VM_PHYSSEG_MAX is 32."); 327 } 328 ATF_TC_BODY(uvm_physseg_100, tc) 329 { 330 paddr_t pa; 331 332 setup(); 333 334 for(paddr_t i = VALID_START_PFN_1; 335 i < VALID_END_PFN_1; i += PF_STEP) { 336 uvm_page_physload(i, i + PF_STEP, i, i + PF_STEP, 337 VM_FREELIST_DEFAULT); 338 } 339 340 ATF_REQUIRE_EQ(VM_PHYSSEG_MAX, uvm_physseg_get_entries()); 341 342 srandom((unsigned)time(NULL)); 343 for(int i = 0; i < 100; i++) { 344 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_1); 345 PHYS_TO_VM_PAGE(pa); 346 } 347 348 ATF_CHECK_EQ(true, true); 349 } 350 351 ATF_TC(uvm_physseg_1K); 352 ATF_TC_HEAD(uvm_physseg_1K, tc) 353 { 354 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 355 1000 calls, VM_PHYSSEG_MAX is 32."); 356 } 357 ATF_TC_BODY(uvm_physseg_1K, tc) 358 { 359 paddr_t pa; 360 361 setup(); 362 363 for(paddr_t i = VALID_START_PFN_1; 364 i < VALID_END_PFN_1; i += PF_STEP) { 365 uvm_page_physload(i, i + PF_STEP, i, i + PF_STEP, 366 VM_FREELIST_DEFAULT); 367 } 368 369 ATF_REQUIRE_EQ(VM_PHYSSEG_MAX, uvm_physseg_get_entries()); 370 371 srandom((unsigned)time(NULL)); 372 for(int i = 0; i < 1000; i++) { 373 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_1); 374 PHYS_TO_VM_PAGE(pa); 375 } 376 377 ATF_CHECK_EQ(true, true); 378 } 379 380 ATF_TC(uvm_physseg_10K); 381 ATF_TC_HEAD(uvm_physseg_10K, tc) 382 { 383 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 384 10,000 calls, VM_PHYSSEG_MAX is 32."); 385 } 386 ATF_TC_BODY(uvm_physseg_10K, tc) 387 { 388 paddr_t pa; 389 390 setup(); 391 392 for(paddr_t i = VALID_START_PFN_1; 393 i < VALID_END_PFN_1; i += PF_STEP) { 394 uvm_page_physload(i, i + PF_STEP, i, i + PF_STEP, 395 VM_FREELIST_DEFAULT); 396 } 397 398 ATF_REQUIRE_EQ(VM_PHYSSEG_MAX, uvm_physseg_get_entries()); 399 400 srandom((unsigned)time(NULL)); 401 for(int i = 0; i < 10000; i++) { 402 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_1); 403 PHYS_TO_VM_PAGE(pa); 404 } 405 406 ATF_CHECK_EQ(true, true); 407 } 408 409 ATF_TC(uvm_physseg_100K); 410 ATF_TC_HEAD(uvm_physseg_100K, tc) 411 { 412 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 413 100,000 calls, VM_PHYSSEG_MAX is 32."); 414 } 415 ATF_TC_BODY(uvm_physseg_100K, tc) 416 { 417 paddr_t pa; 418 419 setup(); 420 421 for(paddr_t i = VALID_START_PFN_1; 422 i < VALID_END_PFN_1; i += PF_STEP) { 423 uvm_page_physload(i, i + PF_STEP, i, i + PF_STEP, 424 VM_FREELIST_DEFAULT); 425 } 426 427 ATF_REQUIRE_EQ(VM_PHYSSEG_MAX, uvm_physseg_get_entries()); 428 429 srandom((unsigned)time(NULL)); 430 for(int i = 0; i < 100000; i++) { 431 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_1); 432 PHYS_TO_VM_PAGE(pa); 433 } 434 435 ATF_CHECK_EQ(true, true); 436 } 437 438 ATF_TC(uvm_physseg_1M); 439 ATF_TC_HEAD(uvm_physseg_1M, tc) 440 { 441 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 442 1,000,000 calls, VM_PHYSSEG_MAX is 32."); 443 } 444 ATF_TC_BODY(uvm_physseg_1M, tc) 445 { 446 paddr_t pa; 447 448 setup(); 449 450 for(paddr_t i = VALID_START_PFN_1; 451 i < VALID_END_PFN_1; i += PF_STEP) { 452 uvm_page_physload(i, i + PF_STEP, i, i + PF_STEP, 453 VM_FREELIST_DEFAULT); 454 } 455 456 ATF_REQUIRE_EQ(VM_PHYSSEG_MAX, uvm_physseg_get_entries()); 457 458 srandom((unsigned)time(NULL)); 459 for(int i = 0; i < 1000000; i++) { 460 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_1); 461 PHYS_TO_VM_PAGE(pa); 462 } 463 464 ATF_CHECK_EQ(true, true); 465 } 466 467 ATF_TC(uvm_physseg_10M); 468 ATF_TC_HEAD(uvm_physseg_10M, tc) 469 { 470 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 471 10,000,000 calls, VM_PHYSSEG_MAX is 32."); 472 } 473 ATF_TC_BODY(uvm_physseg_10M, tc) 474 { 475 paddr_t pa; 476 477 setup(); 478 479 for(paddr_t i = VALID_START_PFN_1; 480 i < VALID_END_PFN_1; i += PF_STEP) { 481 uvm_page_physload(i, i + PF_STEP, i, i + PF_STEP, 482 VM_FREELIST_DEFAULT); 483 } 484 485 ATF_REQUIRE_EQ(VM_PHYSSEG_MAX, uvm_physseg_get_entries()); 486 487 srandom((unsigned)time(NULL)); 488 for(int i = 0; i < 10000000; i++) { 489 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_1); 490 PHYS_TO_VM_PAGE(pa); 491 } 492 493 ATF_CHECK_EQ(true, true); 494 } 495 496 ATF_TC(uvm_physseg_100M); 497 ATF_TC_HEAD(uvm_physseg_100M, tc) 498 { 499 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 500 100,000,000 calls, VM_PHYSSEG_MAX is 32."); 501 } 502 ATF_TC_BODY(uvm_physseg_100M, tc) 503 { 504 paddr_t pa; 505 506 setup(); 507 508 for(paddr_t i = VALID_START_PFN_1; 509 i < VALID_END_PFN_1; i += PF_STEP) { 510 uvm_page_physload(i, i + PF_STEP, i, i + PF_STEP, 511 VM_FREELIST_DEFAULT); 512 } 513 514 ATF_REQUIRE_EQ(VM_PHYSSEG_MAX, uvm_physseg_get_entries()); 515 516 srandom((unsigned)time(NULL)); 517 for(int i = 0; i < 100000000; i++) { 518 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_1); 519 PHYS_TO_VM_PAGE(pa); 520 } 521 522 ATF_CHECK_EQ(true, true); 523 } 524 525 ATF_TC(uvm_physseg_1MB); 526 ATF_TC_HEAD(uvm_physseg_1MB, tc) 527 { 528 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 529 10,000,000 calls, VM_PHYSSEG_MAX is 32 on 1 MB Segment."); 530 } 531 ATF_TC_BODY(uvm_physseg_1MB, t) 532 { 533 paddr_t pa = 0; 534 535 paddr_t pf = 0; 536 537 psize_t pf_chunk_size = 0; 538 539 psize_t npages1 = (VALID_END_PFN_1 - VALID_START_PFN_1); 540 541 psize_t npages2 = (VALID_END_PFN_2 - VALID_START_PFN_2); 542 543 struct vm_page *slab = malloc(sizeof(struct vm_page) * 544 (npages1 + npages2)); 545 546 setup(); 547 548 /* We start with zero segments */ 549 ATF_REQUIRE_EQ(true, uvm_physseg_plug(VALID_START_PFN_1, npages1, NULL)); 550 ATF_REQUIRE_EQ(1, uvm_physseg_get_entries()); 551 552 /* Post boot: Fake all segments and pages accounted for. */ 553 uvm_page_init_fake(slab, npages1 + npages2); 554 555 ATF_REQUIRE_EQ(true, uvm_physseg_plug(VALID_START_PFN_2, npages2, NULL)); 556 ATF_REQUIRE_EQ(2, uvm_physseg_get_entries()); 557 558 srandom((unsigned)time(NULL)); 559 for(pf = VALID_START_PFN_2; pf < VALID_END_PFN_2; pf += PF_STEP) { 560 pf_chunk_size = (psize_t) random() % (psize_t) (PF_STEP - 1) + 1; 561 uvm_physseg_unplug(pf, pf_chunk_size); 562 } 563 564 for(int i = 0; i < 10000000; i++) { 565 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_2); 566 if(pa < ctob(VALID_START_PFN_2)) 567 pa += ctob(VALID_START_PFN_2); 568 PHYS_TO_VM_PAGE(pa); 569 } 570 571 ATF_CHECK_EQ(true, true); 572 } 573 574 ATF_TC(uvm_physseg_64MB); 575 ATF_TC_HEAD(uvm_physseg_64MB, tc) 576 { 577 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 578 10,000,000 calls, VM_PHYSSEG_MAX is 32 on 64 MB Segment."); 579 } 580 ATF_TC_BODY(uvm_physseg_64MB, t) 581 { 582 paddr_t pa = 0; 583 584 paddr_t pf = 0; 585 586 psize_t pf_chunk_size = 0; 587 588 psize_t npages1 = (VALID_END_PFN_1 - VALID_START_PFN_1); 589 590 psize_t npages2 = (VALID_END_PFN_3 - VALID_START_PFN_3); 591 592 struct vm_page *slab = malloc(sizeof(struct vm_page) * 593 (npages1 + npages2)); 594 595 setup(); 596 597 /* We start with zero segments */ 598 ATF_REQUIRE_EQ(true, uvm_physseg_plug(VALID_START_PFN_1, npages1, NULL)); 599 ATF_REQUIRE_EQ(1, uvm_physseg_get_entries()); 600 601 /* Post boot: Fake all segments and pages accounted for. */ 602 uvm_page_init_fake(slab, npages1 + npages2); 603 604 ATF_REQUIRE_EQ(true, uvm_physseg_plug(VALID_START_PFN_3, npages2, NULL)); 605 ATF_REQUIRE_EQ(2, uvm_physseg_get_entries()); 606 607 srandom((unsigned)time(NULL)); 608 for(pf = VALID_START_PFN_3; pf < VALID_END_PFN_3; pf += PF_STEP) { 609 pf_chunk_size = (psize_t) random() % (psize_t) (PF_STEP - 1) + 1; 610 uvm_physseg_unplug(pf, pf_chunk_size); 611 } 612 613 for(int i = 0; i < 10000000; i++) { 614 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_3); 615 if(pa < ctob(VALID_START_PFN_3)) 616 pa += ctob(VALID_START_PFN_3); 617 PHYS_TO_VM_PAGE(pa); 618 } 619 620 ATF_CHECK_EQ(true, true); 621 } 622 623 ATF_TC(uvm_physseg_128MB); 624 ATF_TC_HEAD(uvm_physseg_128MB, tc) 625 { 626 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 627 10,000,000 calls, VM_PHYSSEG_MAX is 32 on 128 MB Segment."); 628 } 629 ATF_TC_BODY(uvm_physseg_128MB, t) 630 { 631 paddr_t pa = 0; 632 633 paddr_t pf = 0; 634 635 psize_t pf_chunk_size = 0; 636 637 psize_t npages1 = (VALID_END_PFN_1 - VALID_START_PFN_1); 638 639 psize_t npages2 = (VALID_END_PFN_4 - VALID_START_PFN_4); 640 641 struct vm_page *slab = malloc(sizeof(struct vm_page) 642 * (npages1 + npages2)); 643 644 setup(); 645 646 /* We start with zero segments */ 647 ATF_REQUIRE_EQ(true, uvm_physseg_plug(VALID_START_PFN_1, npages1, NULL)); 648 ATF_REQUIRE_EQ(1, uvm_physseg_get_entries()); 649 650 /* Post boot: Fake all segments and pages accounted for. */ 651 uvm_page_init_fake(slab, npages1 + npages2); 652 653 ATF_REQUIRE_EQ(true, uvm_physseg_plug(VALID_START_PFN_2, npages2, NULL)); 654 ATF_REQUIRE_EQ(2, uvm_physseg_get_entries()); 655 656 srandom((unsigned)time(NULL)); 657 for(pf = VALID_START_PFN_4; pf < VALID_END_PFN_4; pf += PF_STEP) { 658 pf_chunk_size = (psize_t) random() % (psize_t) (PF_STEP - 1) + 1; 659 uvm_physseg_unplug(pf, pf_chunk_size); 660 } 661 662 for(int i = 0; i < 10000000; i++) { 663 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_4); 664 if(pa < ctob(VALID_START_PFN_4)) 665 pa += ctob(VALID_START_PFN_4); 666 PHYS_TO_VM_PAGE(pa); 667 } 668 669 ATF_CHECK_EQ(true, true); 670 } 671 672 ATF_TC(uvm_physseg_256MB); 673 ATF_TC_HEAD(uvm_physseg_256MB, tc) 674 { 675 atf_tc_set_md_var(tc, "descr", "Load test uvm_phys_to_vm_page() with \ 676 10,000,000 calls, VM_PHYSSEG_MAX is 32 on 256 MB Segment."); 677 } 678 ATF_TC_BODY(uvm_physseg_256MB, t) 679 { 680 paddr_t pa = 0; 681 682 paddr_t pf = 0; 683 684 psize_t pf_chunk_size = 0; 685 686 psize_t npages1 = (VALID_END_PFN_1 - VALID_START_PFN_1); 687 688 psize_t npages2 = (VALID_END_PFN_5 - VALID_START_PFN_5); 689 690 struct vm_page *slab = malloc(sizeof(struct vm_page) * (npages1 + npages2)); 691 692 setup(); 693 694 /* We start with zero segments */ 695 ATF_REQUIRE_EQ(true, uvm_physseg_plug(VALID_START_PFN_1, npages1, NULL)); 696 ATF_REQUIRE_EQ(1, uvm_physseg_get_entries()); 697 698 /* Post boot: Fake all segments and pages accounted for. */ 699 uvm_page_init_fake(slab, npages1 + npages2); 700 701 ATF_REQUIRE_EQ(true, uvm_physseg_plug(VALID_START_PFN_2, npages2, NULL)); 702 ATF_REQUIRE_EQ(2, uvm_physseg_get_entries()); 703 704 srandom((unsigned)time(NULL)); 705 for(pf = VALID_START_PFN_5; pf < VALID_END_PFN_5; pf += PF_STEP) { 706 pf_chunk_size = (psize_t) random() % (psize_t) (PF_STEP - 1) + 1; 707 uvm_physseg_unplug(pf, pf_chunk_size); 708 } 709 710 for(int i = 0; i < 10000000; i++) { 711 pa = (paddr_t) random() % (paddr_t) ctob(VALID_END_PFN_5); 712 if(pa < ctob(VALID_END_PFN_5)) 713 pa += ctob(VALID_START_PFN_5); 714 PHYS_TO_VM_PAGE(pa); 715 } 716 717 ATF_CHECK_EQ(true, true); 718 } 719 720 ATF_TP_ADD_TCS(tp) 721 { 722 /* Fixed memory size tests. */ 723 ATF_TP_ADD_TC(tp, uvm_physseg_100); 724 ATF_TP_ADD_TC(tp, uvm_physseg_1K); 725 ATF_TP_ADD_TC(tp, uvm_physseg_10K); 726 ATF_TP_ADD_TC(tp, uvm_physseg_100K); 727 ATF_TP_ADD_TC(tp, uvm_physseg_1M); 728 ATF_TP_ADD_TC(tp, uvm_physseg_10M); 729 ATF_TP_ADD_TC(tp, uvm_physseg_100M); 730 731 #if defined(UVM_HOTPLUG) 732 /* Variable memory size tests. */ 733 ATF_TP_ADD_TC(tp, uvm_physseg_1MB); 734 ATF_TP_ADD_TC(tp, uvm_physseg_64MB); 735 ATF_TP_ADD_TC(tp, uvm_physseg_128MB); 736 ATF_TP_ADD_TC(tp, uvm_physseg_256MB); 737 #endif /* UVM_HOTPLUG */ 738 739 return atf_no_error(); 740 } 741
Indexes created Mon Sep 22 21:09:42 GMT 2025