QPU Timing Information from SAPI

Timing-Related Fields

The table below lists the timing-related fields available in D-Wave’s Ocean SDK. Ocean users access to this information is from the info field in the dimod sampleset class, as in the example below. Note that the time is given in microseconds.

>>> from dwave.system import DWaveSampler, EmbeddingComposite
>>> sampler = EmbeddingComposite(DWaveSampler())
>>> sampleset = sampler.sample_ising({'a': 1}, {('a', 'b'): 1})
>>> print(sampleset.info["timing"])   
{'qpu_sampling_time': 315,
 'qpu_anneal_time_per_sample': 20,
 'qpu_readout_time_per_sample': 274,
 'qpu_access_time': 9687,
 'qpu_access_overhead_time': 1738,
 'qpu_programming_time': 9372,
 'qpu_delay_time_per_sample': 21,
 'total_post_processing_time': 474,
 'post_processing_overhead_time': 474}

Table 30 Fields that affect qpu_access_time

QMI Time Component	SAPI Field Name	Meaning	Affected by
\(T\)	qpu_access_time	Total time in QPU	All parameters listed below
\(T_p\)	qpu_programming_time	Total time to program the QPU[1]	programming_thermalization, weakly affected by other problem settings (such as \(h\), \(J\), anneal_offsets, flux_offsets, and h_gain_schedule)
\(\Delta\)		Time for additional low-level operations
\(R\)		Number of reads (samples)	num_reads
\(T_s\)	qpu_sampling_time	Total time for \(R\) samples	num_reads, \(T_a\), \(T_r\), \(T_d\)
\(T_a\)	qpu_anneal_time_per_sample	Time for one anneal	anneal_schedule, annealing_time
\(T_r\)	qpu_readout_time_per_sample	Time for one read	Number of qubits read[2]
\(T_d\)	qpu_delay_time_per_sample	Delay between anneals[3]	anneal_schedule, readout_thermalization, reduce_intersample_correlation, (only in case of reverse annealing), reinitialize_state
	total_post_processing_time	Total time for postprocessing	Programming time
	post_processing_overhead_time	Extra time needed to process the last batch	total_post_processing_time

[1]	Even if programming_thermalization is 0, \(T_p\) is typically between 4 and \(40\ \mu s\) depending on processor and describes the time spent setting the \(h\) and \(J\) parameters of the problem as well as other features such as anneal_offsets, flux_offsets, h_gain_schedule.

[2]

The time to read a sample set from a Advantage generation QPU depends on the location of the qubits on the processor and the number of qubits in the sample set: a problem represented by a dozen qubits has shorter read times (and so a shorter \(T_r\), the total_readout_time) than a problem represented by several thousand qubits. For the Advantage QPU, this can be significant. For example, some small problems may take \(25\ \mu s\) per read while a large problem might take \(150\ \mu s\) per read.

[3]	The time returned in the qpu_delay_time_per_sample field is equal to a constant plus the user-specified value, readout_thermalization.

Timing Data Returned by dwave-cloud-client

Below is a sample skeleton of Python code for accessing timing data returned by dwave-cloud-client. Timing values are returned in the computation object and the timing object; further code could query those objects in more detail. The timing object referenced on line 16 is a Python dictionary containing (key, value) pairs. The keys match keywords discussed in this section.

01 import random
02 import datetime as dt
03 from dwave.cloud import Client

04 # Connect using the default or environment connection information
05 with Client.from_config() as client:

06     # Load the default solver
07     solver = client.get_solver()

08     # Build a random Ising model to exactly fit the graph the solver supports
09     linear = {index: random.choice([-1, 1]) for index in solver.nodes}
10     quad = {key: random.choice([-1, 1]) for key in solver.undirected_edges}

11     # Send the problem for sampling, include solver-specific parameter 'num_reads'
12     computation = solver.sample_ising(linear, quad, num_reads=100)
13     computation.wait()

14     # Print the first sample out of a hundred
15     print(computation.samples[0])
16     timing = computation['timing']


17     # Service time
18     time_format = "%Y-%m-%d %H:%M:%S.%f"
19     start_time = dt.datetime.strptime(str(computation.time_received)[:-6], time_format)
20     finish_time = dt.datetime.strptime(str(computation.time_solved)[:-6], time_format)
21     service_time = finish_time - start_time
22     qpu_access_time = timing['qpu_access_time']
23     print("start_time="+str(start_time)+", finish_time="+str(finish_time)+ \
24             ", service_time="+str(service_time)+", qpu_access_time="       \
25             +str(float(qpu_access_time)/1000000))