Update test style.

Signed-off-by: James Brodman <[email protected]>

Author: jbrodman

sycl/test/usm/allocator_vector.cpp

@@ -25,33 +25,35 @@ int main() {
   auto dev = q.get_device();
   auto ctxt = q.get_context();
 
-  if (dev.get_info<info::device::usm_host_allocations>()) {
-    usm_allocator<int, usm::alloc::host> alloc(ctxt, dev);
+  if (!dev.get_info<info::device::usm_host_allocations>()) 
+    return 0;
 
-    std::vector<int, decltype(alloc)> vec(alloc);
-    vec.resize(N);
+  usm_allocator<int, usm::alloc::host> alloc(ctxt, dev);
 
-    for (int i = 0; i < N; i++) {
-      vec[i] = i;
-    }
+  std::vector<int, decltype(alloc)> vec(alloc);
+  vec.resize(N);
 
-    int *res = &vec[0];
-    int *vals = &vec[0];
+  for (int i = 0; i < N; i++) {
+    vec[i] = i;
+  }
+
+  int *res = &vec[0];
+  int *vals = &vec[0];
 
-    auto e1 = q.submit([=](handler &cgh) {
-      cgh.single_task<class foo>([=]() {
-        for (int i = 1; i < N; i++) {
-          res[0] += vals[i];
-        }
-      });
+  auto e1 = q.submit([=](handler &cgh) {
+    cgh.single_task<class foo>([=]() {
+      for (int i = 1; i < N; i++) {
+        res[0] += vals[i];
+      }
     });
+  });
 
-    e1.wait();
+  e1.wait();
 
-    int answer = (N * (N - 1)) / 2;
+  int answer = (N * (N - 1)) / 2;
+
+  if (vec[0] != answer)
+    return -1;
 
-    if (vec[0] != answer)
-      return -1;
-  }
   return 0;
 }

sycl/test/usm/allocatorll.cpp

@@ -30,55 +30,54 @@ int main() {
   auto dev = q.get_device();
   auto ctxt = q.get_context();
 
-  if (dev.get_info<info::device::usm_device_allocations>()) {
-    usm_allocator<Node, usm::alloc::device> alloc(ctxt, dev);
+  if (!dev.get_info<info::device::usm_device_allocations>())
+    return 0;
 
-    Node *d_head = nullptr;
-    Node *d_cur = nullptr;
-    Node h_cur;
+  usm_allocator<Node, usm::alloc::device> alloc(ctxt, dev);
+  Node h_cur;
 
-    d_head = alloc.allocate(1);
-    d_cur = d_head;
+  Node *d_head = alloc.allocate(1);
+  Node *d_cur = d_head;
 
-    for (int i = 0; i < numNodes; i++) {
-      h_cur.Num = i * 2;
+  for (int i = 0; i < numNodes; i++) {
+    h_cur.Num = i * 2;
 
-      if (i != (numNodes - 1)) {
-        h_cur.pNext = alloc.allocate(1);
-      } else {
-        h_cur.pNext = nullptr;
-      }
+    if (i != (numNodes - 1)) {
+      h_cur.pNext = alloc.allocate(1);
+    } else {
+      h_cur.pNext = nullptr;
+    }
 
-      event e0 = q.memcpy(d_cur, &h_cur, sizeof(Node));
-      e0.wait();
+    event e0 = q.memcpy(d_cur, &h_cur, sizeof(Node));
+    e0.wait();
 
-      d_cur = h_cur.pNext;
-    }
+    d_cur = h_cur.pNext;
+  }
 
-    auto e1 = q.submit([=](handler &cgh) {
-      cgh.single_task<class foo>([=]() {
-        Node *pHead = d_head;
-        while (pHead) {
-          pHead->Num = pHead->Num * 2 + 1;
-          pHead = pHead->pNext;
-        }
-      });
+  auto e1 = q.submit([=](handler &cgh) {
+    cgh.single_task<class foo>([=]() {
+      Node *pHead = d_head;
+      while (pHead) {
+        pHead->Num = pHead->Num * 2 + 1;
+        pHead = pHead->pNext;
+      }
     });
+  });
 
-    e1.wait();
+  e1.wait();
 
-    d_cur = d_head;
-    for (int i = 0; i < numNodes; i++) {
-      event c = q.memcpy(&h_cur, d_cur, sizeof(Node));
-      c.wait();
-      alloc.deallocate(d_cur, 1);
+  d_cur = d_head;
+  for (int i = 0; i < numNodes; i++) {
+    event c = q.memcpy(&h_cur, d_cur, sizeof(Node));
+    c.wait();
+    alloc.deallocate(d_cur, 1);
 
-      const int want = i * 4 + 1;
-      if (h_cur.Num != want) {
-        return -1;
-      }
-      d_cur = h_cur.pNext;
+    const int want = i * 4 + 1;
+    if (h_cur.Num != want) {
+      return -2;
     }
+    d_cur = h_cur.pNext;
   }
+
   return 0;
 }

sycl/test/usm/depends_on.cpp

@@ -17,66 +17,65 @@ using namespace cl::sycl;
 
 class foo;
 int main() {
-  int *darray = nullptr;
-  int *sarray = nullptr;
-  int *harray = nullptr;
   const int N = 4;
   const int MAGIC_NUM = 42;
 
   queue q;
   auto dev = q.get_device();
   auto ctxt = q.get_context();
 
-  if (dev.get_info<info::device::usm_device_allocations>() &&
-      dev.get_info<info::device::usm_host_allocations>() &&
-      dev.get_info<info::device::usm_shared_allocations>()) {
-    darray = (int *)malloc_device(N * sizeof(int), dev, ctxt);
-    if (darray == nullptr) {
-      return -1;
-    }
-    sarray = (int *)malloc_shared(N * sizeof(int), dev, ctxt);
+  if (!(dev.get_info<info::device::usm_device_allocations>() &&
+        dev.get_info<info::device::usm_host_allocations>() &&
+        dev.get_info<info::device::usm_shared_allocations>())) 
+    return 0;
 
-    if (sarray == nullptr) {
-      return -1;
-    }
+  int *darray = (int *)malloc_device(N * sizeof(int), dev, ctxt);
+  if (darray == nullptr) {
+    return -1;
+  }
+  int *sarray = (int *)malloc_shared(N * sizeof(int), dev, ctxt);
 
-    harray = (int *)malloc_host(N * sizeof(int), ctxt);
-    if (harray == nullptr) {
-      return -1;
-    }
+  if (sarray == nullptr) {
+    return -1;
+  }
 
-    event e;
-    auto eInit = q.submit([&](handler &cgh) {
-      cgh.depends_on(e);
-      cgh.single_task<class init>([=]() {
-        for (int i = 0; i < N; i++) {
-          sarray[i] = MAGIC_NUM - 1;
-          harray[i] = 1;
-        }
-      });
+  int *harray = (int *)malloc_host(N * sizeof(int), ctxt);
+  if (harray == nullptr) {
+    return -1;
+  }
+
+  event e;
+  auto eInit = q.submit([&](handler &cgh) {
+    cgh.depends_on(e);
+    cgh.single_task<class init>([=]() {
+      for (int i = 0; i < N; i++) {
+        sarray[i] = MAGIC_NUM - 1;
+        harray[i] = 1;
+      }
     });
+  });
 
-    auto eMemset = q.memset(darray, 0, N * sizeof(int));
+  auto eMemset = q.memset(darray, 0, N * sizeof(int));
 
-    auto eKernel = q.submit([=](handler &cgh) {
-      cgh.depends_on({eInit, eMemset});
-      cgh.single_task<class foo>([=]() {
-        for (int i = 0; i < N; i++) {
-          sarray[i] += darray[i] + harray[i];
-        }
-      });
+  auto eKernel = q.submit([=](handler &cgh) {
+    cgh.depends_on({eInit, eMemset});
+    cgh.single_task<class foo>([=]() {
+      for (int i = 0; i < N; i++) {
+        sarray[i] += darray[i] + harray[i];
+      }
     });
+  });
 
-    eKernel.wait();
+  eKernel.wait();
 
-    for (int i = 0; i < N; i++) {
-      if (sarray[i] != MAGIC_NUM) {
-        return -1;
-      }
+  for (int i = 0; i < N; i++) {
+    if (sarray[i] != MAGIC_NUM) {
+      return -2;
     }
-    free(darray, ctxt);
-    free(sarray, ctxt);
-    free(harray, ctxt);
   }
+  free(darray, ctxt);
+  free(sarray, ctxt);
+  free(harray, ctxt);
+
   return 0;
 }

sycl/test/usm/dmemll.cpp

@@ -30,59 +30,59 @@ int main() {
   auto dev = q.get_device();
   auto ctxt = q.get_context();
 
-  if (dev.get_info<info::device::usm_device_allocations>()) {
-    Node *d_head = nullptr;
-    Node *d_cur = nullptr;
-    Node h_cur;
-
-    d_head = (Node *)malloc_device(sizeof(Node), dev, ctxt);
-    if (d_head == nullptr) {
-      return -1;
-    }
-    d_cur = d_head;
-
-    for (int i = 0; i < numNodes; i++) {
-      h_cur.Num = i * 2;
-
-      if (i != (numNodes - 1)) {
-        h_cur.pNext = (Node *)malloc_device(sizeof(Node), dev, ctxt);
-        if (h_cur.pNext == nullptr) {
-          return -1;
-        }
-      } else {
-        h_cur.pNext = nullptr;
-      }
+  if (!dev.get_info<info::device::usm_device_allocations>())
+    return 0;
 
-      event e0 = q.memcpy(d_cur, &h_cur, sizeof(Node));
-      e0.wait();
+  Node h_cur;
+
+  Node *d_head = (Node *)malloc_device(sizeof(Node), dev, ctxt);
+  if (d_head == nullptr) {
+    return -1;
+  }
+  Node *d_cur = d_head;
 
-      d_cur = h_cur.pNext;
+  for (int i = 0; i < numNodes; i++) {
+    h_cur.Num = i * 2;
+
+    if (i != (numNodes - 1)) {
+      h_cur.pNext = (Node *)malloc_device(sizeof(Node), dev, ctxt);
+      if (h_cur.pNext == nullptr) {
+        return -1;
+      }
+    } else {
+      h_cur.pNext = nullptr;
     }
 
-    auto e1 = q.submit([=](handler &cgh) {
-      cgh.single_task<class foo>([=]() {
-        Node *pHead = d_head;
-        while (pHead) {
-          pHead->Num = pHead->Num * 2 + 1;
-          pHead = pHead->pNext;
-        }
-      });
+    event e0 = q.memcpy(d_cur, &h_cur, sizeof(Node));
+    e0.wait();
+
+    d_cur = h_cur.pNext;
+  }
+
+  auto e1 = q.submit([=](handler &cgh) {
+    cgh.single_task<class foo>([=]() {
+      Node *pHead = d_head;
+      while (pHead) {
+        pHead->Num = pHead->Num * 2 + 1;
+        pHead = pHead->pNext;
+      }
     });
+  });
 
-    e1.wait();
+  e1.wait();
 
-    d_cur = d_head;
-    for (int i = 0; i < numNodes; i++) {
-      event c = q.memcpy(&h_cur, d_cur, sizeof(Node));
-      c.wait();
-      free(d_cur, ctxt);
+  d_cur = d_head;
+  for (int i = 0; i < numNodes; i++) {
+    event c = q.memcpy(&h_cur, d_cur, sizeof(Node));
+    c.wait();
+    free(d_cur, ctxt);
 
-      const int want = i * 4 + 1;
-      if (h_cur.Num != want) {
-        return -1;
-      }
-      d_cur = h_cur.pNext;
+    const int want = i * 4 + 1;
+    if (h_cur.Num != want) {
+      return -2;
     }
+    d_cur = h_cur.pNext;
   }
+
   return 0;
 }