|
24 | 24 | import time |
25 | 25 | import warnings |
26 | 26 |
|
| 27 | +import numpy as np |
27 | 28 | import pytest |
28 | 29 |
|
29 | 30 | import dpctl |
|
34 | 35 | _start_deferred_release_watcher, |
35 | 36 | _stop_deferred_release_watcher, |
36 | 37 | ) |
| 38 | +from dpctl.utils import _order_manager |
37 | 39 |
|
38 | 40 | _free_threaded = bool(sysconfig.get_config_var("Py_GIL_DISABLED")) |
39 | 41 |
|
@@ -503,3 +505,168 @@ def __del__(self): |
503 | 505 | timeout=120, |
504 | 506 | ) |
505 | 507 | assert out == "4" |
| 508 | + |
| 509 | + |
| 510 | +def _in_order_queue(*args, cls=dpctl.SyclQueue): |
| 511 | + try: |
| 512 | + return cls(*args, property="in_order") |
| 513 | + except dpctl.SyclQueueCreationError: |
| 514 | + pytest.skip("Queue could not be created for default-selected device") |
| 515 | + |
| 516 | + |
| 517 | +@pytest.fixture(params=[True, False], ids=["last_event", "added_events"]) |
| 518 | +def use_last_event(request, monkeypatch): |
| 519 | + if request.param and not dpctl.SyclQueue.is_get_last_event_available(): |
| 520 | + pytest.skip("sycl_ext_oneapi_in_order_queue_events not available") |
| 521 | + monkeypatch.setattr(_order_manager, "_use_last_event", request.param) |
| 522 | + return request.param |
| 523 | + |
| 524 | + |
| 525 | +def test_in_order_order_manager(): |
| 526 | + q = _in_order_queue() |
| 527 | + _som = dpctl.utils.SequentialOrderManager |
| 528 | + _mngr = _som[q] |
| 529 | + assert _som[q] is _mngr |
| 530 | + assert isinstance(_mngr, _order_manager._InOrderManager) |
| 531 | + assert isinstance(_mngr.submitted_events, list) |
| 532 | + assert isinstance(_mngr.cleanup_events, list) |
| 533 | + _mngr.add_event(dpctl.SyclEvent()) |
| 534 | + _mngr.add_event([dpctl.SyclEvent(), dpctl.SyclEvent()]) |
| 535 | + _mngr.add_cleanup_event(dpctl.SyclEvent()) |
| 536 | + _mngr.add_cleanup_event([dpctl.SyclEvent(), dpctl.SyclEvent()]) |
| 537 | + # complete events are not kept |
| 538 | + assert _mngr.num_cleanup_events == 0 |
| 539 | + _mngr.wait() |
| 540 | + cpy = _mngr.__copy__() |
| 541 | + assert isinstance(cpy, _order_manager._InOrderManager) |
| 542 | + assert cpy.num_cleanup_events == 0 |
| 543 | + _som.clear() |
| 544 | + del cpy |
| 545 | + |
| 546 | + |
| 547 | +@pytest.mark.parametrize("in_order", [True, False]) |
| 548 | +def test_order_manager_add_non_event(in_order): |
| 549 | + q = _in_order_queue() if in_order else dpctl.SyclQueue() |
| 550 | + _mngr = dpctl.utils.SequentialOrderManager[q] |
| 551 | + with pytest.raises(TypeError): |
| 552 | + _mngr.add_event(None) |
| 553 | + with pytest.raises(TypeError): |
| 554 | + _mngr.add_cleanup_event([None]) |
| 555 | + dpctl.utils.SequentialOrderManager.clear() |
| 556 | + |
| 557 | + |
| 558 | +def test_in_order_order_manager_host_task_api(): |
| 559 | + q = _in_order_queue() |
| 560 | + _som = dpctl.utils.SequentialOrderManager |
| 561 | + _mngr = _som[q] |
| 562 | + with warnings.catch_warnings(): |
| 563 | + warnings.simplefilter("error") |
| 564 | + _mngr.add_event_pair(dpctl.SyclEvent(), dpctl.SyclEvent()) |
| 565 | + _mngr.add_event_pair([dpctl.SyclEvent()], dpctl.SyclEvent()) |
| 566 | + assert _mngr.host_task_events == [] |
| 567 | + assert _mngr.num_host_task_events == 0 |
| 568 | + _som.clear() |
| 569 | + |
| 570 | + |
| 571 | +def test_in_order_order_manager_wait_drops_references(stopped_release_watcher): |
| 572 | + q = _in_order_queue() |
| 573 | + _som = dpctl.utils.SequentialOrderManager |
| 574 | + _mngr = _som[q] |
| 575 | + |
| 576 | + released = [] |
| 577 | + args = (_Sentinel(released),) |
| 578 | + ev = q.keep_args_alive(args) |
| 579 | + del args |
| 580 | + ev.wait() |
| 581 | + assert not released, "dpctl's thread is stopped, so nothing has run it" |
| 582 | + |
| 583 | + _mngr.wait() |
| 584 | + assert released == [True] |
| 585 | + _som.clear() |
| 586 | + |
| 587 | + |
| 588 | +def test_in_order_order_manager_submitted_events(use_last_event): |
| 589 | + q = _in_order_queue() |
| 590 | + _mngr = dpctl.utils.SequentialOrderManager[q] |
| 591 | + buf = dpctl.memory.MemoryUSMDevice(1024, queue=q) |
| 592 | + # work which is not added to the order manager |
| 593 | + q.memset_async(buf, 1, 1024) |
| 594 | + if use_last_event: |
| 595 | + assert _mngr.num_submitted_events == 1 |
| 596 | + else: |
| 597 | + assert _mngr.num_submitted_events == 0 |
| 598 | + dpctl.utils.SequentialOrderManager.clear() |
| 599 | + |
| 600 | + |
| 601 | +def _fill_in_steps(q, buf, n_fills, mngr=None): |
| 602 | + nbytes = buf.nbytes |
| 603 | + ev = None |
| 604 | + for v in range(1, n_fills + 1): |
| 605 | + ev = q.memset_async(buf, v, nbytes, dEvents=[ev] if ev else None) |
| 606 | + if mngr is not None: |
| 607 | + mngr.add_event(ev) |
| 608 | + mngr.add_cleanup_event(q.keep_args_alive((buf,), [ev])) |
| 609 | + return ev |
| 610 | + |
| 611 | + |
| 612 | +def test_in_order_order_manager_other_queue_depends(): |
| 613 | + if not dpctl.SyclQueue.is_get_last_event_available(): |
| 614 | + pytest.skip("sycl_ext_oneapi_in_order_queue_events not available") |
| 615 | + q_in = _in_order_queue() |
| 616 | + q_other = dpctl.SyclQueue(q_in.sycl_context, q_in.sycl_device) |
| 617 | + _mngr = dpctl.utils.SequentialOrderManager[q_in] |
| 618 | + n_fills = 8 |
| 619 | + buf = dpctl.memory.MemoryUSMDevice(64 * 1024 * 1024, queue=q_in) |
| 620 | + host = np.empty(buf.nbytes, dtype=np.uint8) |
| 621 | + for _ in range(5): |
| 622 | + q_in.memset(buf, 0, buf.nbytes) |
| 623 | + _fill_in_steps(q_in, buf, n_fills - 1, _mngr) |
| 624 | + # the last fill is not added to the order manager |
| 625 | + q_in.memset_async(buf, n_fills, buf.nbytes) |
| 626 | + q_other.memcpy_async( |
| 627 | + host, buf, buf.nbytes, dEvents=_mngr.submitted_events |
| 628 | + ).wait() |
| 629 | + assert np.all(host == n_fills) |
| 630 | + dpctl.utils.SequentialOrderManager.clear() |
| 631 | + |
| 632 | + |
| 633 | +def test_in_order_order_manager_other_queue_event(use_last_event): |
| 634 | + q_in = _in_order_queue() |
| 635 | + q_other = dpctl.SyclQueue(q_in.sycl_context, q_in.sycl_device) |
| 636 | + _mngr = dpctl.utils.SequentialOrderManager[q_in] |
| 637 | + n_fills = 8 |
| 638 | + buf = dpctl.memory.MemoryUSMDevice(64 * 1024 * 1024, queue=q_in) |
| 639 | + host = np.empty(buf.nbytes, dtype=np.uint8) |
| 640 | + for _ in range(5): |
| 641 | + q_in.memset(buf, 0, buf.nbytes) |
| 642 | + _mngr.add_event(_fill_in_steps(q_other, buf, n_fills)) |
| 643 | + q_in.memcpy_async( |
| 644 | + host, buf, buf.nbytes, dEvents=_mngr.submitted_events |
| 645 | + ).wait() |
| 646 | + assert np.all(host == n_fills) |
| 647 | + q_other.wait() |
| 648 | + dpctl.utils.SequentialOrderManager.clear() |
| 649 | + |
| 650 | + |
| 651 | +class _WaitCountingQueue(dpctl.SyclQueue): |
| 652 | + def __init__(self, *args, **kwargs): |
| 653 | + self.num_waits = 0 |
| 654 | + |
| 655 | + def wait(self): |
| 656 | + self.num_waits += 1 |
| 657 | + super().wait() |
| 658 | + |
| 659 | + |
| 660 | +def test_in_order_order_manager_waits_on_queue(): |
| 661 | + q = _in_order_queue(cls=_WaitCountingQueue) |
| 662 | + _som = dpctl.utils.SequentialOrderManager |
| 663 | + _mngr = _som[q] |
| 664 | + _mngr.wait() |
| 665 | + assert q.num_waits == 1 |
| 666 | + cpy = _mngr.__copy__() |
| 667 | + del cpy |
| 668 | + assert q.num_waits == 2 |
| 669 | + del _mngr |
| 670 | + # clear() runs at exit, and must wait on in-order queues as well |
| 671 | + _som.clear() |
| 672 | + assert q.num_waits > 2 |
0 commit comments