Errors for collectives.

Author: abergeron

src/gpuarray_array_collectives.c

@@ -29,15 +29,16 @@ static inline size_t find_total_elems(const GpuArray* array) {
 static inline int check_gpuarrays(int times_src, const GpuArray* src,
                                   int times_dest, const GpuArray* dest,
                                   size_t* count) {
+  gpucontext *ctx = gpudata_context(src->data);
   size_t count_src, count_dest;
   count_src = find_total_elems(src);
   count_dest = find_total_elems(dest);
   if (times_src * count_src != times_dest * count_dest)
-    return GA_VALUE_ERROR;
+    return error_set(ctx->err, GA_VALUE_ERROR, "Size mismatch for transfer");
   if (src->typecode != dest->typecode)
-    return GA_VALUE_ERROR;
+    return error_set(ctx->err, GA_VALUE_ERROR, "Type mismatch");
   if (!GpuArray_ISALIGNED(src) || !GpuArray_CHKFLAGS(dest, GA_BEHAVED))
-    return GA_UNALIGNED_ERROR;
+    return error_set(ctx->err, GA_UNALIGNED_ERROR, "Misbehaved arrays");
 
   if (times_src >= times_dest)
     *count = count_src;
@@ -50,7 +51,7 @@ int GpuArray_reduce_from(const GpuArray* src, int opcode, int root,
                          gpucomm* comm) {
   size_t total_elems;
   if (!GpuArray_ISALIGNED(src))
-    return GA_UNALIGNED_ERROR;
+    return error_set(ctx->err, GA_UNALIGNED_ERROR, "Unaligned input");
   total_elems = find_total_elems(src);
   return gpucomm_reduce(src->data, src->offset, NULL, 0, total_elems,
                         src->typecode, opcode, root, comm);
@@ -95,10 +96,10 @@ int GpuArray_broadcast(GpuArray* array, int root, gpucomm* comm) {
   GA_CHECK(gpucomm_get_rank(comm, &rank));
   if (rank == root) {
     if (!GpuArray_CHKFLAGS(array, GA_BEHAVED))
-      return GA_UNALIGNED_ERROR;
+      return error_set(ctx->err, GA_UNALIGNED_ERROR, "Unaligned input");
   } else {
     if (!GpuArray_ISALIGNED(array))
-      return GA_UNALIGNED_ERROR;
+      return error_set(ctx->err, GA_UNALIGNED_ERROR, "Unaligned input");
   }
 
   total_elems = find_total_elems(array);

src/gpuarray_buffer_collectives.c

@@ -8,7 +8,7 @@ int gpucomm_new(gpucomm** comm, gpucontext* ctx, gpucommCliqueId comm_id,
                 int ndev, int rank) {
   if (ctx->comm_ops == NULL) {
     *comm = NULL;
-    return GA_UNSUPPORTED_ERROR;
+    return error_set(ctx->err, GA_UNSUPPORTED_ERROR, "Collectives unavailable");
   }
   return ctx->comm_ops->comm_new(comm, ctx, comm_id, ndev, rank);
 }
@@ -30,21 +30,21 @@ gpucontext* gpucomm_context(gpucomm* comm) {
 }
 int gpucomm_gen_clique_id(gpucontext* ctx, gpucommCliqueId* comm_id) {
   if (ctx->comm_ops == NULL)
-    return GA_COMM_ERROR;
+    return error_set(ctx->err, GA_DEVSUP_ERROR, "Collectives unavailable");
   return ctx->comm_ops->generate_clique_id(ctx, comm_id);
 }
 
 int gpucomm_get_count(gpucomm* comm, int* gpucount) {
   gpucontext* ctx = gpucomm_context(comm);
   if (ctx->comm_ops == NULL)
-    return GA_COMM_ERROR;
+    return error_set(ctx->err, GA_DEVSUP_ERROR, "Collectives unavailable");
   return ctx->comm_ops->get_count(comm, gpucount);
 }
 
 int gpucomm_get_rank(gpucomm* comm, int* rank) {
   gpucontext* ctx = gpucomm_context(comm);
   if (ctx->comm_ops == NULL)
-    return GA_COMM_ERROR;
+    return error_set(ctx->err, GA_DEVSUP_ERROR, "Collectives unavailable");
   return ctx->comm_ops->get_rank(comm, rank);
 }
 
@@ -53,7 +53,7 @@ int gpucomm_reduce(gpudata* src, size_t offsrc, gpudata* dest, size_t offdest,
                    gpucomm* comm) {
   gpucontext* ctx = gpucomm_context(comm);
   if (ctx->comm_ops == NULL)
-    return GA_COMM_ERROR;
+    return error_set(ctx->err, GA_DEVSUP_ERROR, "Collectives unavailable");
   return ctx->comm_ops->reduce(src, offsrc, dest, offdest, count, typecode,
                                opcode, root, comm);
 }
@@ -63,7 +63,7 @@ int gpucomm_all_reduce(gpudata* src, size_t offsrc, gpudata* dest,
                        gpucomm* comm) {
   gpucontext* ctx = gpucomm_context(comm);
   if (ctx->comm_ops == NULL)
-    return GA_COMM_ERROR;
+    return error_set(ctx->err, GA_DEVSUP_ERROR, "Collectives unavailable");
   return ctx->comm_ops->all_reduce(src, offsrc, dest, offdest, count, typecode,
                                    opcode, comm);
 }
@@ -73,7 +73,7 @@ int gpucomm_reduce_scatter(gpudata* src, size_t offsrc, gpudata* dest,
                            int opcode, gpucomm* comm) {
   gpucontext* ctx = gpucomm_context(comm);
   if (ctx->comm_ops == NULL)
-    return GA_COMM_ERROR;
+    return error_set(ctx->err, GA_DEVSUP_ERROR, "Collectives unavailable");
   return ctx->comm_ops->reduce_scatter(src, offsrc, dest, offdest, count,
                                        typecode, opcode, comm);
 }
@@ -82,7 +82,7 @@ int gpucomm_broadcast(gpudata* array, size_t offset, size_t count, int typecode,
                       int root, gpucomm* comm) {
   gpucontext* ctx = gpucomm_context(comm);
   if (ctx->comm_ops == NULL)
-    return GA_COMM_ERROR;
+    return error_set(ctx->err, GA_DEVSUP_ERROR, "Collectives unavailable");
   return ctx->comm_ops->broadcast(array, offset, count, typecode, root, comm);
 }
 
@@ -91,7 +91,7 @@ int gpucomm_all_gather(gpudata* src, size_t offsrc, gpudata* dest,
                        gpucomm* comm) {
   gpucontext* ctx = gpucomm_context(comm);
   if (ctx->comm_ops == NULL)
-    return GA_COMM_ERROR;
+    return error_set(ctx->err, GA_DEVSUP_ERROR, "Collectives unavailable");
   return ctx->comm_ops->all_gather(src, offsrc, dest, offdest, count, typecode,
                                    comm);
 }