Rename annotated_malloc to malloc_annotated.

Author: jessicadavies-intel

sycl/doc/extensions/proposed/sycl_ext_oneapi_usm_malloc_properties.asciidoc

@@ -89,13 +89,13 @@ properties P2{bar, foo{1}};
 properties P3{bar, baz}
 
 // APtr1 is of type annotated_ptr<int, decltype(properties{bar, baz, usm_kind<sycl::usm::alloc::device>})>
-auto APtr1 = annotated_malloc_device<int>(N, q, P1);
+auto APtr1 = malloc_device_annotated<int>(N, q, P1);
 
 // APtr2 is of type annotated_ptr<int, decltype(properties{bar, usm_kind<sycl::usm::alloc::device>})>
-auto APtr2 = annotated_malloc_device<int>(N, q, P2);
+auto APtr2 = malloc_device_annotated<int>(N, q, P2);
 
 // APtr3 is of type annotated_ptr<int, decltype(properties{bar, baz, usm_kind<sycl::usm::alloc::device>})>
-auto APtr3 = annotated_malloc_device<int>(N, q, P3);
+auto APtr3 = malloc_device_annotated<int>(N, q, P3);
 
 // Runtime properties are not present on the returned annotated_ptr
 static_assert(std::is_same_v<decltype(APtr1), decltype(APtr3)>);
@@ -104,10 +104,10 @@ static_assert(std::is_same_v<decltype(APtr1), decltype(APtr3)>);
 static_assert(!std::is_same_v<decltype(APtr1), decltype(APtr2)>);
 
 // APtr4 is of type annotated_ptr<int, decltype(properties{usm_kind<sycl::usm::alloc::host>})>
-auto APtr4 = annotated_malloc_host<int>(N, q);
+auto APtr4 = malloc_host_annotated<int>(N, q);
 
 // APtr5 is of type annotated_ptr<int, decltype(properties{usm_kind<sycl::usm::alloc::shared>})>
-auto APtr5 = annotated_malloc_shared<int>(N, q);
+auto APtr5 = malloc_shared_annotated<int>(N, q);
 
 // The USM kinds differ
 static_assert(!std::is_same_v<decltype(APtr4), decltype(APtr5)>);
@@ -123,10 +123,10 @@ using namespace sycl::ext::oneapi::experimental;
 properties P4{bar, foo{1}};
 
 // APtr6 is of type annotated_ptr<int, decltype(properties{bar})>
-auto APtr6 = annotated_malloc<int>(N, q, sycl::usm::alloc::device, P4);
+auto APtr6 = malloc_annotated<int>(N, q, sycl::usm::alloc::device, P4);
 
 // APtr7 is of type annotated_ptr<int, decltype(properties{})>;
-auto APtr7 = annotated_malloc<int>(N, q, sycl::usm::alloc::device);
+auto APtr7 = malloc_annotated<int>(N, q, sycl::usm::alloc::device);
 ----
 
 If the USM memory allocation kind specified by a parameter to the allocation function is different than the USM memory allocation kind specified by the `sycl::ext::oneapi::experimental::usm_kind` property, the function throws a
@@ -140,10 +140,10 @@ using namespace sycl::ext::oneapi::experimental;
 properties P5{usm_kind<sycl::usm::alloc::device>};
 
 // Throws an exception with error code errc::invalid
-auto APtr8 = annotated_malloc<int>(N, q, sycl::usm::alloc::host, P5);
+auto APtr8 = malloc_annotated<int>(N, q, sycl::usm::alloc::host, P5);
 
 // Error: the USM kinds do not agree
-auto APtr9 = annotated_malloc_host<int>(N, q, P5);
+auto APtr9 = malloc_host_annotated<int>(N, q, P5);
 ----
 
 The following example uses the compile-time-constant property `alignment`, defined in the link:../proposed/sycl_ext_oneapi_annotated_ptr.asciidoc[sycl_ext_oneapi_annotated_ptr] extension.
@@ -160,15 +160,15 @@ properties P9{alignment<64>};
 
 // APtr10 is of type annotated_ptr<int, decltype(properties{alignment<512>, usm_kind<sycl::usm::alloc::device>})>
 // The raw pointer of APtr10 is 512-byte aligned
-auto APtr10 = annotated_malloc_device<int>(N, q, P7);
+auto APtr10 = malloc_device_annotated<int>(N, q, P7);
 
 // APtr11 is of type annotated_ptr<int, decltype(properties{alignment<1>, usm_kind<sycl::usm::alloc::device>})>
 // The raw pointer of APtr11 is sizeof(int)-byte aligned
-auto APtr11 = annotated_malloc_device<int>(N, q, P8);
+auto APtr11 = malloc_device_annotated<int>(N, q, P8);
 
 // APtr12 is of type annotated_ptr<void, decltype(properties{alignment<64>, usm_kind<sycl::usm::alloc::device>})>
 // The raw pointer of APtr12 is 512-byte aligned
-auto APtr12 = annotated_malloc_device(512, q, P9);
+auto APtr12 = malloc_device_annotated(512, q, P9);
 ----
 
 This extension also introduces USM memory allocation functions with `properties` support that allow alignment to be specified at runtime, using a separate parameter of type `size_t`.
@@ -266,15 +266,15 @@ a@
 ----
 template<typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc_device(
+malloc_device_annotated(
    size_t numBytes,
    const device& syclDevice,
    const context& syclContext,
    const propertyListA &propList = properties{})
 ----
 a@ Returns an `annotated_ptr` containing a raw pointer to the newly allocated memory on `syclDevice` on
 success.  The allocation size is specified in bytes.  This memory is not
-accessible on the host.  Memory allocated by `annotated_malloc_device`
+accessible on the host.  Memory allocated by `malloc_device_annotated`
 must be deallocated with `sycl::free` to avoid memory leaks.
 On failure, the raw pointer of the returned `annotated_ptr` will be `nullptr`.
 
@@ -304,7 +304,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc_device(
+malloc_device_annotated(
    size_t count,
    const device& syclDevice,
    const context& syclContext,
@@ -313,7 +313,7 @@ annotated_malloc_device(
 a@  Returns an `annotated_ptr` containing a raw pointer to the newly allocated memory on `syclDevice` on
 success.  The allocation size is specified in number of elements of type
 `T`.  This memory is not accessible on the host.  Memory allocated
-by `annotated_malloc_device` must be deallocated with
+by `malloc_device_annotated` must be deallocated with
 `sycl::free` to avoid memory leaks.
 On failure, the raw pointer of the returned `annotated_ptr` will be `nullptr`.
 
@@ -341,7 +341,7 @@ a@
 ----
 template<typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc_device(
+malloc_device_annotated(
    size_t numBytes,
    const queue& syclQueue,
    const propertyListA &propList = properties{})
@@ -371,7 +371,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc_device(
+malloc_device_annotated(
    size_t count,
    const queue& syclQueue,
    const propertyListA &propList = properties{})
@@ -557,15 +557,15 @@ a@
 ----
 template <typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc_host(
+malloc_host_annotated(
    size_t numBytes,
    const context& syclContext,
    const propertyListA &propList = properties{})
 ----
 a@ Returns an `annotated_ptr` containing a raw pointer to the newly allocated host memory on
 success. This allocation is specified in bytes. The allocation is
 accessible on the host and devices contained in the specified `context`.
-Memory allocated by `annotated_malloc_host` must be
+Memory allocated by `malloc_host_annotated` must be
 deallocated with `sycl::free` to avoid memory leaks.
 On failure, the raw pointer of the returned `annotated_ptr` will be `nullptr`.
 
@@ -591,7 +591,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc_host(
+malloc_host_annotated(
    size_t count,
    const context& syclContext,
    const propertyListA &propList = properties{})
@@ -600,7 +600,7 @@ a@ Returns an `annotated_ptr` containing a raw pointer to the newly allocated ho
 success. This allocation is specified in number of elements of type `T`.
 The allocation is accessible on the host and devices contained in the
 specified `context`.
-Memory allocated by `annotated_malloc_host` must be
+Memory allocated by `malloc_host_annotated` must be
 deallocated with `sycl::free` to avoid memory leaks.
 On failure, the raw pointer of the returned `annotated_ptr` will be `nullptr`.
 
@@ -624,7 +624,7 @@ a@
 ----
 template <typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc_host(
+malloc_host_annotated(
    size_t numBytes,
    const queue& syclQueue,
    const propertyListA &propList = properties{})
@@ -653,7 +653,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc_host(
+malloc_host_annotated(
    size_t count,
    const queue& syclQueue,
    const propertyListA &propList = properties{})
@@ -823,7 +823,7 @@ a@
 ----
 template <typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc_shared(
+malloc_shared_annotated(
    size_t numBytes,
    const device& syclDevice,
    const context& syclContext,
@@ -861,7 +861,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc_shared(
+malloc_shared_annotated(
    size_t count,
    const device& syclDevice,
    const context& syclContext,
@@ -898,7 +898,7 @@ a@
 ----
 template <typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc_shared(
+malloc_shared_annotated(
    size_t numBytes,
    const queue& syclQueue,
    const propertyListA &propList = properties{})
@@ -928,7 +928,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc_shared(
+malloc_shared_annotated(
    size_t count,
    const queue& syclQueue,
    const propertyListA &propList = properties{})
@@ -1113,7 +1113,7 @@ a@
 ----
 template <typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc(
+malloc_annotated(
    size_t numBytes,
    const device& syclDevice,
    const context& syclContext,
@@ -1148,7 +1148,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc(
+malloc_annotated(
    size_t count,
    const device& syclDevice,
    const context& syclContext,
@@ -1183,7 +1183,7 @@ a@
 ----
 template <typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc(
+malloc_annotated(
    size_t numBytes,
    const queue& syclQueue,
    sycl::usm::alloc kind,
@@ -1209,7 +1209,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc(
+malloc_annotated(
    size_t count,
    const queue& syclQueue,
    sycl::usm::alloc kind,
@@ -1387,7 +1387,7 @@ a@
 ----
 template <typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc(
+malloc_annotated(
    size_t numBytes,
    const device& syclDevice,
    const context& syclContext,
@@ -1419,7 +1419,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc(
+malloc_annotated(
    size_t count,
    const device& syclDevice,
    const context& syclContext,
@@ -1449,7 +1449,7 @@ a@
 ----
 template <typename propertyListA, typename propertyListB>
 annotated_ptr<void, propertyListB>
-annotated_malloc(
+malloc_annotated(
    size_t numBytes,
    const queue& syclQueue,
    const propertyListA &propList)
@@ -1476,7 +1476,7 @@ template <typename T,
           typename propertyListA,
           typename propertyListB>
 annotated_ptr<T, propertyListB>
-annotated_malloc(
+malloc_annotated(
    size_t count,
    const queue& syclQueue,
    const propertyListA &propList)
@@ -1569,8 +1569,8 @@ using namespace sycl::ext::oneapi::experimental;
 
 // APtr and BPtr are of type
 // annotated_ptr<int*, decltype(properties{usm_kind<sycl::usm::alloc::device>})>
-auto APtr = annotated_malloc_device<int>(N, q);
-auto BPtr = annotated_malloc_device<int>(N, q);
+auto APtr = malloc_device_annotated<int>(N, q);
+auto BPtr = malloc_device_annotated<int>(N, q);
 
 // Deallocate the memory pointed to by the raw pointer of APtr
 free(APtr, q);