carray 1.2.0 → 1.3.0

data/ca_obj_fake.c

@@ -17,9 +17,9 @@ typedef struct {
   int8_t    data_type;
   int8_t    rank;
   int32_t   flags;
-  int32_t   bytes;
-  int32_t   elements;
-  int32_t  *dim;
+  ca_size_t   bytes;
+  ca_size_t   elements;
+  ca_size_t  *dim;
   char     *ptr;
   CArray   *mask;
   CArray   *parent;
@@ -39,10 +39,10 @@ static VALUE rb_cCAFake;
 /* ------------------------------------------------------------------- */
 
 int
-ca_fake_setup (CAFake *ca, CArray *parent, int8_t data_type, int32_t bytes)
+ca_fake_setup (CAFake *ca, CArray *parent, int8_t data_type, ca_size_t bytes)
 {
   int8_t rank;
-  int32_t *dim, elements;
+  ca_size_t *dim, elements;
 
   /* check arguments */
 
@@ -61,13 +61,13 @@ ca_fake_setup (CAFake *ca, CArray *parent, int8_t data_type, int32_t bytes)
   ca->elements  = elements;
   ca->ptr       = NULL;
   ca->mask      = NULL;
-  ca->dim       = ALLOC_N(int32_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, rank);
 
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
 
-  memcpy(ca->dim, dim, rank * sizeof(int32_t));
+  memcpy(ca->dim, dim, rank * sizeof(ca_size_t));
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -81,7 +81,7 @@ ca_fake_setup (CAFake *ca, CArray *parent, int8_t data_type, int32_t bytes)
 }
 
 CAFake *
-ca_fake_new (CArray *parent, int8_t data_type, int32_t bytes)
+ca_fake_new (CArray *parent, int8_t data_type, ca_size_t bytes)
 {
   CAFake *ca = ALLOC(CAFake);
   ca_fake_setup(ca, parent, data_type, bytes);
@@ -110,21 +110,21 @@ ca_fake_func_clone (void *ap)
 }
 
 static char *
-ca_fake_func_ptr_at_addr (void *ap, int32_t addr)
+ca_fake_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CAFake *ca = (CAFake *) ap;
   return ca->ptr + ca->bytes * addr;
 }
 
 static char *
-ca_fake_func_ptr_at_index (void *ap, int32_t *idx)
+ca_fake_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CAFake *ca = (CAFake *) ap;
   return ca_func[CA_OBJ_ARRAY].ptr_at_index(ca, idx);
 }
 
 static void
-ca_fake_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_fake_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAFake *ca = (CAFake *) ap;
   if ( ca->parent->bytes <= 32 ) {
@@ -141,7 +141,7 @@ ca_fake_func_fetch_index (void *ap, int32_t *idx, void *ptr)
 }
 
 static void
-ca_fake_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_fake_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAFake *ca = (CAFake *) ap;
   if ( ca->parent->bytes <= 32 ) {
@@ -168,8 +168,8 @@ ca_fake_func_allocate (void *ap)
   /* initialize elements with 0 for CA_OBJECT data_type */
   if ( ca->data_type == CA_OBJECT ) {
     VALUE *p = (VALUE *) ca->ptr;
-    VALUE zero = INT2FIX(0);
-    int32_t i;
+    VALUE zero = SIZE2NUM(0);
+    ca_size_t i;
     for (i=0; i<ca->elements; i++) {
       *p++ = zero;
     }
@@ -189,8 +189,8 @@ ca_fake_func_attach (void *ap)
   /* initialize elements with 0 for CA_OBJECT data_type */
   if ( ca->data_type == CA_OBJECT ) {
     VALUE *p = (VALUE *) ca->ptr;
-    VALUE zero = INT2FIX(0);
-    int32_t i;
+    VALUE zero = SIZE2NUM(0);
+    ca_size_t i;
     for (i=0; i<ca->elements; i++) {
       *p++ = zero;
     }
@@ -315,7 +315,7 @@ ca_operation_function_t ca_fake_func = {
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_fake_new (VALUE cary, int8_t data_type, int32_t bytes)
+rb_ca_fake_new (VALUE cary, int8_t data_type, ca_size_t bytes)
 {
   volatile VALUE obj;
   CArray *parent;
@@ -341,11 +341,11 @@ rb_ca_fake (int argc, VALUE *argv, VALUE self)
   volatile VALUE obj, rtype, ropt, rbytes = Qnil;
   CArray *ca;
   int8_t  data_type;
-  int32_t bytes;
+  ca_size_t bytes;
 
   Data_Get_Struct(self, CArray, ca);
 
-  rb_scan_args(argc, argv, "11", &rtype, &ropt);
+  rb_scan_args(argc, argv, "11", (VALUE *) &rtype, (VALUE *) &ropt);
   rb_scan_options(ropt, "bytes", &rbytes);
 
   rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
@@ -360,7 +360,7 @@ rb_ca_fake_type (VALUE self, VALUE rtype, VALUE rbytes)
 {
   volatile VALUE obj;
   int8_t  data_type;
-  int32_t bytes;
+  ca_size_t bytes;
   rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
   obj = rb_ca_fake_new(self, data_type, bytes);
   rb_ca_data_type_import(obj, rtype);

data/ca_obj_farray.c

@@ -17,16 +17,16 @@ typedef struct {
   int8_t    data_type;
   int8_t    rank;
   int32_t   flags;
-  int32_t   bytes;
-  int32_t   elements;
-  int32_t  *dim;
+  ca_size_t   bytes;
+  ca_size_t   elements;
+  ca_size_t  *dim;
   char     *ptr;
   CArray   *mask;
   CArray   *parent;
   uint32_t  attach;
   uint8_t   nosync;
   /* --------------- */
-  int32_t   step;
+  ca_size_t   step;
 } CAFarray;
 
 static int8_t CA_OBJ_FARRAY;
@@ -44,7 +44,7 @@ int
 ca_farray_setup (CAFarray *ca, CArray *parent)
 {
   int8_t rank, data_type;
-  int32_t *dim, elements, bytes;
+  ca_size_t *dim, elements, bytes;
   int i;
 
   /* check arguments */
@@ -63,7 +63,7 @@ ca_farray_setup (CAFarray *ca, CArray *parent)
   ca->elements  = elements;
   ca->ptr       = NULL;
   ca->mask      = NULL;
-  ca->dim       = ALLOC_N(int32_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, rank);
 
   ca->parent    = parent;
   ca->attach    = 0;
@@ -121,11 +121,11 @@ ca_farray_func_clone (void *ap)
 #define ca_farray_func_ptr_at_index ca_array_func_ptr_at_index
 
 static void
-ca_farray_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_farray_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAFarray *ca = (CAFarray *) ap;
   int8_t  rank = ca->rank;
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   int i;
   for (i=0; i<rank; i++) {
     idx0[i] = idx[rank-1-i];
@@ -134,11 +134,11 @@ ca_farray_func_fetch_index (void *ap, int32_t *idx, void *ptr)
 }
 
 static void
-ca_farray_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_farray_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAFarray *ca = (CAFarray *) ap;
   int8_t  rank = ca->rank;
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   int i;
   for (i=0; i<rank; i++) {
     idx0[i] = idx[rank-1-i];
@@ -253,11 +253,11 @@ ca_operation_function_t ca_farray_func = {
 
 
 static void
-ca_fa_attach_loop (CAFarray *ca, int8_t level, int32_t *idx, int32_t *idx0)
+ca_fa_attach_loop (CAFarray *ca, int8_t level, ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t step = ca->step;
-  int32_t dim = ca->dim[level];
-  int32_t i;
+  ca_size_t step = ca->step;
+  ca_size_t dim = ca->dim[level];
+  ca_size_t i;
   if ( level == ca->rank - 1 ) {
     idx[level] = 0;
     idx0[0]    = 0;
@@ -327,17 +327,17 @@ ca_fa_attach_loop (CAFarray *ca, int8_t level, int32_t *idx, int32_t *idx0)
 static void
 ca_fa_attach (CAFarray *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_fa_attach_loop(ca, 0, idx, idx0);
 }
 
 static void
-ca_fa_sync_loop (CAFarray *ca, int8_t level, int32_t *idx, int32_t *idx0)
+ca_fa_sync_loop (CAFarray *ca, int8_t level, ca_size_t *idx, ca_size_t *idx0)
 {
-  int32_t step = ca->step;
-  int32_t dim  = ca->dim[level];
-  int32_t i;
+  ca_size_t step = ca->step;
+  ca_size_t dim  = ca->dim[level];
+  ca_size_t i;
 
   if ( level == ca->rank - 1 ) {
     idx[level] = 0;
@@ -407,8 +407,8 @@ ca_fa_sync_loop (CAFarray *ca, int8_t level, int32_t *idx, int32_t *idx0)
 static void
 ca_fa_sync (CAFarray *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_fa_sync_loop(ca, 0, idx, idx0);
 }
 

data/ca_obj_field.c

@@ -17,16 +17,16 @@ typedef struct {
   int8_t    data_type;
   int8_t    rank;
   int32_t   flags;
-  int32_t   bytes;
-  int32_t   elements;
-  int32_t  *dim;
+  ca_size_t   bytes;
+  ca_size_t   elements;
+  ca_size_t  *dim;
   char     *ptr;
   CArray   *mask;
   CArray   *parent;
   uint32_t  attach;
   uint8_t   nosync;
   /* -------------*/
-  int32_t   offset;
+  ca_size_t   offset;
 } CAField;
 
 static int8_t CA_OBJ_FIELD;
@@ -42,10 +42,10 @@ static VALUE rb_cCAField;
 
 int
 ca_field_setup (CAField *ca, CArray *parent,
-                int32_t offset, int8_t data_type, int32_t bytes)
+                ca_size_t offset, int8_t data_type, ca_size_t bytes)
 {
   int8_t rank;
-  int32_t elements;
+  ca_size_t elements;
 
   /* check arguments */
 
@@ -75,14 +75,14 @@ ca_field_setup (CAField *ca, CArray *parent,
   ca->elements  = elements;
   ca->ptr       = NULL;
   ca->mask      = NULL;
-  ca->dim       = ALLOC_N(int32_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, rank);
 
   ca->parent    = parent;
   ca->attach    = 0;
   ca->nosync    = 0;
   ca->offset    = offset;
 
-  memcpy(ca->dim, parent->dim, rank * sizeof(int32_t));
+  memcpy(ca->dim, parent->dim, rank * sizeof(ca_size_t));
 
   if ( ca_has_mask(parent) ) {
     ca_create_mask(ca);
@@ -96,7 +96,7 @@ ca_field_setup (CAField *ca, CArray *parent,
 }
 
 CAField *
-ca_field_new (CArray *parent, int32_t offset, int8_t data_type, int32_t bytes)
+ca_field_new (CArray *parent, ca_size_t offset, int8_t data_type, ca_size_t bytes)
 {
   CAField *ca = ALLOC(CAField);
   ca_field_setup(ca, parent, offset, data_type, bytes);
@@ -128,11 +128,11 @@ ca_field_func_clone (void *ap)
 }
 
 static char *
-ca_field_func_ptr_at_addr (void *ap, int32_t addr)
+ca_field_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CAField *ca = (CAField *) ap;
   if ( ! ca->ptr ) {
-    int32_t idx[CA_RANK_MAX];
+    ca_size_t idx[CA_RANK_MAX];
     ca_addr2index((CArray *)ca, addr, idx);
     return ca_ptr_at_index(ca, idx);
   }
@@ -142,12 +142,13 @@ ca_field_func_ptr_at_addr (void *ap, int32_t addr)
 }
 
 static char *
-ca_field_func_ptr_at_index (void *ap, int32_t *idx)
+ca_field_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CAField *ca = (CAField *) ap;
   if ( ! ca->ptr ) {
-    int32_t *dim    = ca->dim;
-    int32_t i, n;
+    ca_size_t *dim    = ca->dim;
+    int8_t i;
+    ca_size_t n;
     n = idx[0];                  /* n = idx[0]*dim[1]*dim[2]*...*dim[rank-1] */
     for (i=1; i<ca->rank; i++) { /*    + idx[1]*dim[1]*dim[2]*...*dim[rank-1] */
       n = dim[i]*n+idx[i];       /*    ... + idx[rank-2]*dim[1] + idx[rank-1] */
@@ -166,7 +167,7 @@ ca_field_func_ptr_at_index (void *ap, int32_t *idx)
 }
 
 static void
-ca_field_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_field_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAField *ca = (CAField *) ap;
   if ( ca->parent->bytes <= 32 ) {
@@ -183,7 +184,7 @@ ca_field_func_fetch_index (void *ap, int32_t *idx, void *ptr)
 }
 
 static void
-ca_field_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_field_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAField *ca = (CAField *) ap;
   if ( ca->parent->bytes <= 32 ) {
@@ -313,9 +314,9 @@ ca_operation_function_t ca_field_func = {
 static void
 ca_field_attach (CAField *ca)
 {
-  int32_t pbytes = ca->parent->bytes;
-  int32_t bytes = ca->bytes;
-  int32_t n = ca->elements;
+  ca_size_t pbytes = ca->parent->bytes;
+  ca_size_t bytes = ca->bytes;
+  ca_size_t n = ca->elements;
 
   switch ( ca->data_type ) {
   case CA_BOOLEAN:
@@ -380,9 +381,9 @@ ca_field_attach (CAField *ca)
 static void
 ca_field_sync (CAField *ca)
 {
-  int32_t pbytes = ca->parent->bytes;
-  int32_t bytes = ca->bytes;
-  int32_t n = ca->elements;
+  ca_size_t pbytes = ca->parent->bytes;
+  ca_size_t bytes = ca->bytes;
+  ca_size_t n = ca->elements;
 
   switch ( ca->data_type ) {
   case CA_BOOLEAN:
@@ -447,8 +448,8 @@ ca_field_sync (CAField *ca)
 static void
 ca_field_fill (CAField *ca, char *ptr)
 {
-  int32_t pbytes = ca->parent->bytes;
-  int32_t n = ca->elements;
+  ca_size_t pbytes = ca->parent->bytes;
+  ca_size_t n = ca->elements;
   char *q = ca_ptr_at_addr(ca->parent, 0) + ca->offset;
 
   switch ( ca->data_type ) {
@@ -509,7 +510,7 @@ ca_field_fill (CAField *ca, char *ptr)
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_field_new (VALUE cary, int32_t offset, int8_t data_type, int32_t bytes)
+rb_ca_field_new (VALUE cary, ca_size_t offset, int8_t data_type, ca_size_t bytes)
 {
   volatile VALUE obj;
   CArray *parent;
@@ -562,7 +563,7 @@ rb_ca_field (int argc, VALUE *argv, VALUE self)
   volatile VALUE obj, voffset, rtype, ropt, rbytes = Qnil;
   CArray *ca;
   int8_t  data_type;
-  int32_t offset, bytes;
+  ca_size_t offset, bytes;
 
   if ( argc == 1 ) {
     return rb_ca_field_as_member(self, argv[0]);
@@ -574,16 +575,16 @@ rb_ca_field (int argc, VALUE *argv, VALUE self)
   /* CArray#field(offset, data_class) */
   /* CArray#field(offset, template) */
 
-  rb_scan_args(argc, argv, "21", &voffset, &rtype, &ropt);
+  rb_scan_args(argc, argv, "21", (VALUE *) &voffset, (VALUE *) &rtype, (VALUE *) &ropt);
   rb_scan_options(ropt, "bytes", &rbytes);
 
-  offset = NUM2INT(voffset);
+  offset = NUM2SIZE(voffset);
 
   if ( rb_obj_is_carray(rtype) ) {
     CArray *ct;
-    int32_t dim[CA_RANK_MAX];
+    ca_size_t dim[CA_RANK_MAX];
     int8_t rank;
-    int i, j;
+    int8_t i, j;
     Data_Get_Struct(rtype, CArray, ct);
     data_type = CA_FIXLEN;
     bytes     = ct->bytes * ct->elements;

data/ca_obj_grid.c

@@ -17,9 +17,9 @@ typedef struct {
   int8_t    data_type;
   int8_t    rank;
   int32_t   flags;
-  int32_t   bytes;
-  int32_t   elements;
-  int32_t  *dim;
+  ca_size_t   bytes;
+  ca_size_t   elements;
+  ca_size_t  *dim;
   char     *ptr;
   CArray   *mask;
   CArray   *parent;
@@ -40,12 +40,12 @@ static VALUE rb_cCAGrid;
 static int8_t CA_OBJ_GRID;
 
 int
-ca_grid_setup (CAGrid *ca, CArray *parent, int32_t *dim,
+ca_grid_setup (CAGrid *ca, CArray *parent, ca_size_t *dim,
                CArray **grid, int8_t *contig, int share)
 {
   int8_t rank, data_type;
-  int32_t *dim0;
-  int32_t elements, bytes;
+  ca_size_t *dim0;
+  ca_size_t elements, bytes;
   double  length;
   int i, j, k;
 
@@ -76,7 +76,7 @@ ca_grid_setup (CAGrid *ca, CArray *parent, int32_t *dim,
   ca->elements  = elements;
   ca->ptr       = NULL;
   ca->mask      = NULL;
-  ca->dim       = ALLOC_N(int32_t, rank);
+  ca->dim       = ALLOC_N(ca_size_t, rank);
 
   ca->parent    = parent;
   ca->attach    = 0;
@@ -92,23 +92,23 @@ ca_grid_setup (CAGrid *ca, CArray *parent, int32_t *dim,
     ca->contig = ALLOC_N(int8_t, rank);
   }
 
-  memcpy(ca->dim, dim, rank * sizeof(int32_t));
+  memcpy(ca->dim, dim, rank * sizeof(ca_size_t));
 
   if ( ! share ) {
     for (i=0; i<rank; i++) {
       if ( grid[i] ) {
         if ( ca_is_any_masked(grid[i]) ) {
-          int32_t gsize = grid[i]->elements - ca_count_masked(grid[i]);
+          ca_size_t gsize = grid[i]->elements - ca_count_masked(grid[i]);
           boolean8_t *m;
-          int32_t n;
-          ca->grid[i] = carray_new(CA_INT32, 1, &gsize, 0, NULL);
+          ca_size_t n;
+          ca->grid[i] = carray_new(CA_SIZE, 1, &gsize, 0, NULL);
           m = (boolean8_t *)grid[i]->mask->ptr;
           n = 0;
           for (j=0; j<grid[i]->elements; j++) {
             if ( ! *m ) {
-              k = ((int32_t*)grid[i]->ptr)[j];
+              k = ((ca_size_t*)grid[i]->ptr)[j];
               CA_CHECK_INDEX(k, dim0[i]);
-              ((int32_t*)ca->grid[i]->ptr)[n] = k;
+              ((ca_size_t*)ca->grid[i]->ptr)[n] = k;
               n++;
             }
             m++;
@@ -118,17 +118,17 @@ ca_grid_setup (CAGrid *ca, CArray *parent, int32_t *dim,
         else {
           ca->grid[i] = ca_template(grid[i]);
           for (j=0; j<grid[i]->elements; j++) {
-            k = ((int32_t*)grid[i]->ptr)[j];
+            k = ((ca_size_t*)grid[i]->ptr)[j];
             CA_CHECK_INDEX(k, dim0[i]);
-            ((int32_t*)ca->grid[i]->ptr)[j] = k;
+            ((ca_size_t*)ca->grid[i]->ptr)[j] = k;
           }
           ca->contig[i] = 0;
         }
       }
       else {
-        int32_t *p;
-        ca->grid[i] = carray_new(CA_INT32, 1, &dim[i], 0, NULL);
-        p = (int32_t *)ca->grid[i]->ptr;
+        ca_size_t *p;
+        ca->grid[i] = carray_new(CA_SIZE, 1, &dim[i], 0, NULL);
+        p = (ca_size_t *)ca->grid[i]->ptr;
         for (j=0; j<dim[i]; j++) {
           *p++ = j;
         }
@@ -145,7 +145,7 @@ ca_grid_setup (CAGrid *ca, CArray *parent, int32_t *dim,
 }
 
 CAGrid *
-ca_grid_new (CArray *parent, int32_t *dim, CArray **grid)
+ca_grid_new (CArray *parent, ca_size_t *dim, CArray **grid)
 {
   CAGrid *ca = ALLOC(CAGrid);
   ca_grid_setup(ca, parent, dim, grid, NULL, 0);
@@ -153,7 +153,7 @@ ca_grid_new (CArray *parent, int32_t *dim, CArray **grid)
 }
 
 CAGrid *
-ca_grid_new_share (CArray *parent, int32_t *dim, CArray **grid, int8_t *contig)
+ca_grid_new_share (CArray *parent, ca_size_t *dim, CArray **grid, int8_t *contig)
 {
   CAGrid *ca = ALLOC(CAGrid);
   ca_grid_setup(ca, parent, dim, grid, contig, 1);
@@ -164,7 +164,7 @@ static void
 free_ca_grid (void *ap)
 {
   CAGrid *ca = (CAGrid *) ap;
-  int32_t i;
+  ca_size_t i;
   if ( ca != NULL ) {
     ca_free(ca->mask);
     if ( ! (ca->flags & CA_FLAG_SHARE_INDEX)) {
@@ -193,11 +193,11 @@ ca_grid_func_clone (void *ap)
 }
 
 static char *
-ca_grid_func_ptr_at_addr (void *ap, int32_t addr)
+ca_grid_func_ptr_at_addr (void *ap, ca_size_t addr)
 {
   CAGrid *ca = (CAGrid *) ap;
   if ( ! ca->ptr ) {
-    int32_t idx[CA_RANK_MAX];
+    ca_size_t idx[CA_RANK_MAX];
     ca_addr2index((CArray *)ca, addr, idx);
     return ca_ptr_at_index(ca, idx);
   }
@@ -207,17 +207,18 @@ ca_grid_func_ptr_at_addr (void *ap, int32_t addr)
 }
 
 static char *
-ca_grid_func_ptr_at_index (void *ap, int32_t *idx)
+ca_grid_func_ptr_at_index (void *ap, ca_size_t *idx)
 {
   CAGrid *ca = (CAGrid *) ap;
   if ( ! ca->ptr ) {
     CArray **grid = ca->grid;
-    int32_t *dim0 = ca->parent->dim;
-    int32_t  n, i;
+    ca_size_t *dim0 = ca->parent->dim;
+    int8_t   i;
+    ca_size_t  n;
 
     n = 0;
     for (i=0; i<ca->rank; i++) {
-      n = dim0[i]*n + *(int32_t*) ca_ptr_at_addr(grid[i], idx[i]);
+      n = dim0[i]*n + *(ca_size_t*) ca_ptr_at_addr(grid[i], idx[i]);
     }
 
     if ( ca->parent->ptr == NULL ) {
@@ -233,12 +234,12 @@ ca_grid_func_ptr_at_index (void *ap, int32_t *idx)
 }
 
 static void
-ca_grid_func_fetch_index (void *ap, int32_t *idx, void *ptr)
+ca_grid_func_fetch_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAGrid *ca = (CAGrid *) ap;
   CArray **grid = ca->grid;
-  int32_t idx0[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t idx0[CA_RANK_MAX];
+  int8_t i;
   for (i=0; i<ca->rank; i++) {
     ca_fetch_addr(grid[i], idx[i], &idx0[i]);
   }
@@ -246,12 +247,12 @@ ca_grid_func_fetch_index (void *ap, int32_t *idx, void *ptr)
 }
 
 static void
-ca_grid_func_store_index (void *ap, int32_t *idx, void *ptr)
+ca_grid_func_store_index (void *ap, ca_size_t *idx, void *ptr)
 {
   CAGrid *ca = (CAGrid *) ap;
   CArray **grid = ca->grid;
-  int32_t idx0[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t idx0[CA_RANK_MAX];
+  int8_t i;
   for (i=0; i<ca->rank; i++) {
     ca_fetch_addr(grid[i], idx[i], &idx0[i]);
   }
@@ -370,7 +371,7 @@ ca_operation_function_t ca_grid_func = {
 
 #define proc_grid_attach(type) \
   { \
-    int32_t *pi = (int32_t*) ca_ptr_at_addr(grid[level], 0); \
+    ca_size_t *pi = (ca_size_t*) ca_ptr_at_addr(grid[level], 0); \
     type *p = (type*) ca_ptr_at_index(ca, idx); \
     type *q = (type*) ca_ptr_at_index(ca->parent, idx0); \
     for (i=0; i<ca->dim[level]; i++, pi++, p++) { \
@@ -380,10 +381,10 @@ ca_operation_function_t ca_grid_func = {
   }
 
 static void
-ca_grid_attach_loop (CAGrid *ca, int16_t level, int32_t *idx, int32_t *idx0)
+ca_grid_attach_loop (CAGrid *ca, int16_t level, ca_size_t *idx, ca_size_t *idx0)
 {
   CArray **grid = ca->grid;
-  int32_t i, k;
+  ca_size_t i, k;
 
   if ( level == ca->rank - 1 ) {
     idx[level] = 0;
@@ -400,7 +401,7 @@ ca_grid_attach_loop (CAGrid *ca, int16_t level, int32_t *idx, int32_t *idx0)
       case 8: proc_grid_attach(float64_t); break;
       default:
         {
-          int32_t *pi = (int32_t*) ca_ptr_at_addr(grid[level], 0);
+          ca_size_t *pi = (ca_size_t*) ca_ptr_at_addr(grid[level], 0);
           char *p = ca_ptr_at_index(ca, idx);
           char *q;
           idx0[level] = 0;
@@ -422,8 +423,8 @@ ca_grid_attach_loop (CAGrid *ca, int16_t level, int32_t *idx, int32_t *idx0)
       }
     }
     else {
-      int32_t *pi;
-      pi = (int32_t*) ca_ptr_at_addr(grid[level], 0);
+      ca_size_t *pi;
+      pi = (ca_size_t*) ca_ptr_at_addr(grid[level], 0);
       for (i=0; i<ca->dim[level]; i++, pi++) {
         k = *pi;
         idx[level]  = i;
@@ -437,14 +438,14 @@ ca_grid_attach_loop (CAGrid *ca, int16_t level, int32_t *idx, int32_t *idx0)
 static void
 ca_grid_attach (CAGrid *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_grid_attach_loop(ca, (int16_t) 0, idx, idx0);
 }
 
 #define proc_grid_sync(type) \
   { \
-    int32_t *pi = (int32_t*) ca_ptr_at_addr(grid[level], 0); \
+    ca_size_t *pi = (ca_size_t*) ca_ptr_at_addr(grid[level], 0); \
     type *p = (type*) ca_ptr_at_index(ca, idx); \
     type *q = (type*) ca_ptr_at_index(ca->parent, idx0); \
     for (i=0; i<ca->dim[level]; i++, pi++, p++) { \
@@ -454,10 +455,10 @@ ca_grid_attach (CAGrid *ca)
   }
 
 static void
-ca_grid_sync_loop (CAGrid *ca, int16_t level, int32_t *idx, int32_t *idx0)
+ca_grid_sync_loop (CAGrid *ca, int16_t level, ca_size_t *idx, ca_size_t *idx0)
 {
   CArray **grid = ca->grid;
-  int32_t i, k;
+  ca_size_t i, k;
 
   if ( level == ca->rank - 1 ) {
     idx[level] = 0;
@@ -474,7 +475,7 @@ ca_grid_sync_loop (CAGrid *ca, int16_t level, int32_t *idx, int32_t *idx0)
       case 8: proc_grid_sync(float64_t); break;
       default:
         {
-          int32_t *pi = (int32_t*) ca_ptr_at_addr(grid[level], 0);
+          ca_size_t *pi = (ca_size_t*) ca_ptr_at_addr(grid[level], 0);
           char *p = ca_ptr_at_index(ca, idx);
           char *q;
           idx0[level] = 0;
@@ -497,7 +498,7 @@ ca_grid_sync_loop (CAGrid *ca, int16_t level, int32_t *idx, int32_t *idx0)
     }
     else {
       for (i=0; i<ca->dim[level]; i++) {
-        k = *(int32_t*) ca_ptr_at_addr(grid[level], i);
+        k = *(ca_size_t*) ca_ptr_at_addr(grid[level], i);
         idx[level]  = i;
         idx0[level] = k;
         ca_grid_sync_loop(ca, level+1, idx, idx0);
@@ -509,14 +510,14 @@ ca_grid_sync_loop (CAGrid *ca, int16_t level, int32_t *idx, int32_t *idx0)
 static void
 ca_grid_sync (CAGrid *ca)
 {
-  int32_t idx[CA_RANK_MAX];
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_grid_sync_loop(ca, (int16_t) 0, idx, idx0);
 }
 
 #define proc_grid_fill(type) \
   { \
-    int32_t *pi = (int32_t*) ca_ptr_at_addr(grid[level], 0); \
+    ca_size_t *pi = (ca_size_t*) ca_ptr_at_addr(grid[level], 0); \
     type fval = *(type*)ptr; \
     type *q = (type*) ca_ptr_at_index(ca->parent, idx0); \
     for (i=0; i<ca->dim[level]; i++, pi++) { \
@@ -527,10 +528,10 @@ ca_grid_sync (CAGrid *ca)
 
 static void
 ca_grid_fill_loop (CAGrid *ca, char *ptr,
-                  int16_t level, int32_t *idx0)
+                  int16_t level, ca_size_t *idx0)
 {
   CArray **grid = ca->grid;
-  int32_t i, k;
+  ca_size_t i, k;
   if ( level == ca->rank - 1 ) {
     idx0[level] = 0;
     if ( ca->contig[level] ) {
@@ -548,7 +549,7 @@ ca_grid_fill_loop (CAGrid *ca, char *ptr,
       case 8: proc_grid_fill(float64_t); break;
       default:
         {
-          int32_t *pi = (int32_t*) ca_ptr_at_addr(grid[level], 0);
+          ca_size_t *pi = (ca_size_t*) ca_ptr_at_addr(grid[level], 0);
           char *q;
           idx0[level] = 0;
           q = ca_ptr_at_index(ca->parent, idx0);
@@ -569,7 +570,7 @@ ca_grid_fill_loop (CAGrid *ca, char *ptr,
     }
     else {
       for (i=0; i<ca->dim[level]; i++) {
-        k = *(int32_t*) ca_ptr_at_addr(grid[level], i);
+        k = *(ca_size_t*) ca_ptr_at_addr(grid[level], i);
         idx0[level] = k;
         ca_grid_fill_loop(ca, ptr, level+1, idx0);
       }
@@ -580,14 +581,14 @@ ca_grid_fill_loop (CAGrid *ca, char *ptr,
 static void
 ca_grid_fill (CAGrid *ca, char *ptr)
 {
-  int32_t idx0[CA_RANK_MAX];
+  ca_size_t idx0[CA_RANK_MAX];
   ca_grid_fill_loop(ca, ptr, (int16_t) 0, idx0);
 }
 
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_grid_new (VALUE cary, int32_t *dim, CArray **grid)
+rb_ca_grid_new (VALUE cary, ca_size_t *dim, CArray **grid)
 {
   volatile VALUE obj;
   CArray *parent;
@@ -615,9 +616,9 @@ rb_ca_grid (int argc, VALUE *argv, VALUE self)
   volatile VALUE list = rb_ary_new();
   CArray *ca;
   CArray *ci[CA_RANK_MAX];
-  int32_t dim[CA_RANK_MAX];
+  ca_size_t dim[CA_RANK_MAX];
   CArray *grid[CA_RANK_MAX];
-  int32_t i;
+  ca_size_t i;
 
   Data_Get_Struct(self, CArray, ca);
 
@@ -629,9 +630,9 @@ rb_ca_grid (int argc, VALUE *argv, VALUE self)
   else if ( RARRAY_LEN(ridx) < ca->rank ) {
     volatile VALUE ref;
     CArray *cv;
-    int32_t rdim[CA_RANK_MAX];
-    int32_t rrank = RARRAY_LEN(ridx);
-    int32_t j = 0, k;
+    ca_size_t rdim[CA_RANK_MAX];
+    ca_size_t rrank = RARRAY_LEN(ridx);
+    ca_size_t j = 0, k;
     for (i=0; i<rrank; i++) {
       rval = rb_ary_entry(ridx, i);
       if ( rb_obj_is_carray(rval) ) {
@@ -668,12 +669,12 @@ rb_ca_grid (int argc, VALUE *argv, VALUE self)
         }
       }
       else if ( rb_obj_is_kind_of(rval, rb_cRange) ) {
-        rval = rb_funcall(rb_mKernel, rb_intern("CA_INT32"), 1, rval);
+        rval = rb_funcall(rb_mKernel, rb_intern("CA_SIZE"), 1, rval);
       }
       else if ( TYPE(rval) == T_ARRAY ) {
         rb_raise(rb_eRuntimeError, "not implemented for this index");
       }
-      ci[i] = ca_wrap_readonly(rval, CA_INT32);
+      ci[i] = ca_wrap_readonly(rval, CA_SIZE);
       rb_ary_push(list, rval);
       ca_attach(ci[i]);