Qiskit / qiskit
90%
main: 89%

LAST BUILD BRANCH: remove_deprecated_function_arguments/1
DEFAULT BRANCH: main
Repo Added
Files 914
Badge
Embed ▾
README BADGES
x

If you need to use a raster PNG badge, change the '.svg' to '.png' in the link

Markdown

Textile

RDoc

HTML

Rst

LAST BUILD ON BRANCH gh-readonly-queue/main/pr-12942-2d3db9a6e66fd70a5406ab94d49fb3b0b29f9225
branch: gh-readonly-queue/main/pr-12942-2d3db9a6e66fd70a5406ab94d49fb3b0b29f9225
CHANGE BRANCH
x

coverage: 89.704% (+0.01%) from 89.694%
10393926662

push

github

web-flow 
Use `OnceCell` to cache Python operations (#12942)

We were previously using `RefCell` to handle the interior mutability for
the Python-operation caches.  This works fine, but has two problems:

- `RefCell<Py<PyAny>>` is two pointers wide
- we had to do heavier dynamic runtime checks for the borrow status on
  every access, including simple gets.

This commit moves the caching to instead use `OnceCell`.  The internal
tracking for a `OnceCell<T>` is just whether an internal `Option<T>` is
in the `Some` variant, and since `Option<Py<PyAny>>` will use the
null-pointer optimisation for space, this means that
`OnceCell<Py<PyAny>>` is only a single pointer wide.  Since it's not
permissible to take out a mutable reference to the interior, there is
also no dynamic runtime checking---just the null-pointer check that the
cell is initialised---so access is faster as well.

We can still clear the cache if we hold a mutable reference to the
`OnceCell`, and since every method that can invalidate the cache also
necessarily changes Rust-space, they certainly require mutable
references to the cell, making it safe.

There is a risk here, though, in `OnceCell::get_or_init`.  This function
is not re-entrant; one cannot attempt the initialisation while another
thread is initialising it.  Typically this is not an issue, since the
type isn't `Sync`, however PyO3 allows types that are only `Send` and
_not_ `Sync` to be put in `pyclass`es, which Python can then share
between threads.  This is usually safe due to the GIL mediating access
to Python-space objects, so there are no data races.  However, if the
initialiser passed to `get_or_init` yields control at any point to the
Python interpreter (such as by calling a method on a Python object),
this gives it a chance to block the thread and allow another Python
thread to run.  The other thread could then attempt to enter the same
cache initialiser, which is a violation of its contract.

PyO3's `GILOnceCell` can protect against ... (continued)

38 of 40 new or added lines in 4 files covered. (95.0%)

8 existing lines in 3 files now uncovered.

67530 of 75281 relevant lines covered (89.7%)

366727.04 hits per line

Relevant lines Covered
75281 RELEVANT LINES 67530 COVERED LINES
366727.04 HITS PER LINE
Source Files on gh-readonly-queue/main/pr-12942-2d3db9a6e66fd70a5406ab94d49fb3b0b29f9225

Recent builds

Builds Branch Commit Type Ran Committer Via Coverage
10393926662 gh-readonly-queue/main/pr-12942-2d3db9a6e66fd70a5406ab94d49fb3b0b29f9225 Use `OnceCell` to cache Python operations (#12942) We were previously using `RefCell` to handle the interior mutability for the Python-operation caches. This works fine, but has two problems: - `RefCell<Py<PyAny>>` is two pointers wide - we had... push web-flow github
89.7
See All Builds (8713)