Slightly optimize ParameterVector construction (Qiskit#10403)

This commit optimizes the construction code for the ParameterVector and
ParameterVectorElement classes. The construction of these objects was
primarily dominated by the UUID construction time. This is because each
element in the vector was calling uuid4() to generate a random unique
identifier for each Parameter element. However, we don't need a truly
random identifier as we just need to avoid collisions with identically
named elements. So instead of calling uuid4() n times this commit opts
to call uuid4() once and then just use an index offset of that value.
This is slightly faster because we don't need to need run the full
uuid4 algorithm each time and instead just wrap an integer in uuid
object. While this does slightly increase the change of a collision
between identically named ParameterVectors, in practice it should still
be sufficiently rare. At the same time the classes are slotted to speed
up attribute access and shrink the memory footprint of using these
objects.

The geometric mean of the runtime of creating 10x 2424000 element
ParamterVector objects goes from 15.702722168587812 to 13.738723886030732
sec with this commit. While not a huge improvement it is a consistent
incremental gain that doesn't require any data model changes. To make
the classes significantly faster we'll likely need to change the data
model for Paramter, ParameterVector, etc to facilitate faster creation.

Author: mtreinish

qiskit/circuit/parameter.py

@@ -50,6 +50,8 @@ class Parameter(ParameterExpression):
            bc.draw('mpl')
     """
 
+    __slots__ = ("_name", "_uuid", "_hash")
+
     def __new__(cls, name, uuid=None):  # pylint: disable=unused-argument
         # Parameter relies on self._uuid being set prior to other attributes
         # (e.g. symbol_map) which may depend on self._uuid for Parameter's hash

qiskit/circuit/parametervector.py

@@ -12,14 +12,16 @@
 
 """Parameter Vector Class to simplify management of parameter lists."""
 
-from uuid import uuid4
+from uuid import uuid4, UUID
 
 from .parameter import Parameter
 
 
 class ParameterVectorElement(Parameter):
     """An element of a ParameterVector."""
 
+    ___slots__ = ("_vector", "_index")
+
     def __new__(cls, vector, index, uuid=None):  # pylint:disable=unused-argument
         obj = object.__new__(cls)
 
@@ -34,7 +36,7 @@ def __new__(cls, vector, index, uuid=None):  # pylint:disable=unused-argument
     def __getnewargs__(self):
         return (self.vector, self.index, self._uuid)
 
-    def __init__(self, vector, index):
+    def __init__(self, vector, index, uuid=None):  # pylint: disable=unused-argument
         name = f"{vector.name}[{index}]"
         super().__init__(name)
         self._vector = vector
@@ -69,12 +71,16 @@ def __setstate__(self, state):
 class ParameterVector:
     """ParameterVector class to quickly generate lists of parameters."""
 
+    __slots__ = ("_name", "_params", "_size", "_root_uuid")
+
     def __init__(self, name, length=0):
         self._name = name
-        self._params = []
         self._size = length
-        for i in range(length):
-            self._params += [ParameterVectorElement(self, i)]
+        self._root_uuid = uuid4()
+        root_uuid_int = self._root_uuid.int
+        self._params = [
+            ParameterVectorElement(self, i, UUID(int=root_uuid_int + i)) for i in range(length)
+        ]
 
     @property
     def name(self):
@@ -119,6 +125,11 @@ def resize(self, length):
         This is to ensure that the parameter instances do not change.
         """
         if length > len(self._params):
-            for i in range(len(self._params), length):
-                self._params += [ParameterVectorElement(self, i)]
+            root_uuid_int = self._root_uuid.int
+            self._params.extend(
+                [
+                    ParameterVectorElement(self, i, UUID(int=root_uuid_int + i))
+                    for i in range(len(self._params), length)
+                ]
+            )
         self._size = length