add test for composite specialization constant

also removes "v" as a permitted specialization constant intermediate data type, as composite specialization constants are broken into multiple specialization constants, so structs end up passed as a single constant while the program expects multiple, and therefore, doesn't work as intended

Author: ndgrigorian

dpctl/program/_program.pyx

@@ -282,16 +282,16 @@ cdef class SpecializationConstant:
       If the constructor is invoked with a single variadic argument, the
       argument is expected to either expose the Python buffer protocol or be
       coercible to a NumPy array. If the argument is coercible to a NumPy array
-      or is one, it must have a supported data type (bool, integral, floating
-      point, or void). The specialization constant will be constructed from the
+      or is one, it must have a supported data type (bool, integral, or
+      floating point). The specialization constant will be constructed from the
       data in the buffer
 
     - ``SpecializationConstant(spec_id, dtype, obj)``
     If the constructor is invoked with two variadic arguments, and the first
     argument is a string, it is interpreted as a NumPy ``dtype`` string and the
     second argument will be coerced to a NumPy array with that data type.
     The data type specified by the first argument must be a supported data
-    type (bool, integral, floating point, or void).
+    type (bool, integral, or floating point).
 
     - ``SpecializationConstant(spec_id, nbytes, raw_ptr)``
       If the constructor is invoked with two variadic arguments where both are
@@ -360,13 +360,13 @@ cdef class SpecializationConstant:
             )
 
         if isinstance(target_obj, np.ndarray):
-            if target_obj.dtype.kind not in ("b", "i", "u", "f", "c", "V"):
+            if target_obj.dtype.kind not in ("b", "i", "u", "f", "c"):
                 raise TypeError(
                     "Coercion of input to buffer resulted in an unsupported "
                     f"data type '{target_obj.dtype}'. When coercing objects, "
                     "`SpecializationConstant` expects the data to coerce to a "
-                    "supported type: bool, integral, real or complex floating "
-                    "point, or void. To pass arbitrary data, use a "
+                    "supported type: bool, integral, or real or complex "
+                    "floating point. To pass arbitrary data, use a "
                     "`memoryview` or `bytes` object, or pass the pointer and "
                     "size directly."
                 )

dpctl/tests/input_files/specialization_constant_composite.spv

@@ -300,3 +300,44 @@ def test_create_kernel_bundle_with_spec_const():
     ht_e.wait()
 
     assert np.all(y == 43)
+
+
+def test_create_kernel_bundle_with_composite_spec_const():
+    try:
+        q = dpctl.SyclQueue()
+    except dpctl.SyclQueueCreationError:
+        pytest.skip("Could not create default queue")
+
+    # composite specialization constants are separated into individual
+    # specialization constants with unique spec_ids
+    sp1 = dpctl_prog.SpecializationConstant(0, "i4", 10)
+    sp2 = dpctl_prog.SpecializationConstant(1, "f4", 2.5)
+    sp3 = dpctl_prog.SpecializationConstant(2, "?", 1)
+
+    spirv_file = get_spirv_abspath("specialization_constant_composite.spv")
+    with open(spirv_file, "br") as spv:
+        spv_bytes = spv.read()
+
+    kb = dpctl_prog.create_kernel_bundle_from_spirv(
+        q, spv_bytes, specializations=[sp1, sp2, sp3]
+    )
+    kernel = kb.get_sycl_kernel("_ZTS21StructSpecConstKernel")
+
+    n = 128
+    x = np.ones(n, dtype="f4")
+    y = np.zeros_like(x)
+
+    x_usm = dpctl.memory.MemoryUSMDevice(x.nbytes, queue=q)
+    y_usm = dpctl.memory.MemoryUSMDevice(y.nbytes, queue=q)
+
+    e1 = q.memcpy_async(x_usm, x, x.nbytes)
+    e2 = q.submit(kernel, [x_usm, y_usm], [n], dEvents=[e1])
+    e3 = q.memcpy_async(y, y_usm, y.nbytes, [e2])
+
+    ht_e = q._submit_keep_args_alive([x_usm], [e3])
+
+    e3.wait()
+    ht_e.wait()
+
+    # 1.0 * 10 + 2.5 = 12.5
+    assert np.all(y == 12.5)