Text archives Help

---

Author: hansong
Date: Tue Sep  6 17:02:04 2005
New Revision: 533

Modified:
   branches/itanium2/Model/Groups/varray.h
Log:
make array index/length types INT instead of int; should define INT as 
unsigned int when going above 2 billion and long long above 4 billion; 
potential impact on performance with long long index'd arrays has not been 
measured.

Modified: branches/itanium2/Model/Groups/varray.h
==============================================================================
--- branches/itanium2/Model/Groups/varray.h     (original)
+++ branches/itanium2/Model/Groups/varray.h     Tue Sep  6 17:02:04 2005
@@ -17,13 +17,16 @@
 #include <assert.h>
 #include <stdio.h>
 
-#define DEBUG_ARRAY
+//#define DEBUG_ARRAY
+
+//#define INT long long
+#define INT unsigned int
 
 template <class T>
 class VArray {
 protected:
-       int curLen;
-       int curMaxLen;
+       INT curLen;
+       INT curMaxLen;
        T* array;
 public:
        VArray() {
@@ -31,21 +34,21 @@
                array = NULL;
        }
 
-       VArray(int initMaxLen) {
+       VArray(INT initMaxLen) {
                init(initMaxLen);
        }
-       VArray(int initMaxLen, int initVal) {
+       VArray(INT initMaxLen, INT initVal) {
                init(initMaxLen, initVal);
        }
 
-       void init(int initMaxLen) {
+       void init(INT initMaxLen) {
                curLen = 0;
                curMaxLen = initMaxLen;
                array = (T*)malloc(curMaxLen * sizeof(T));
                assert (array != NULL);
        }
 
-       void init(int initMaxLen, int initVal) {
+       void init(INT initMaxLen, INT initVal) {
                curLen = 0;
                curMaxLen = initMaxLen;
                array = (T*)malloc(curMaxLen * sizeof(T));
@@ -53,9 +56,9 @@
                memset(array, initVal, curMaxLen*sizeof(T));
        }
 
-       inline int getLen() { return curLen; }
-       inline int getNum() { return curLen; }
-       inline void setLen(int len) {
+       inline INT getLen() { return curLen; }
+       inline INT getNum() { return curLen; }
+       inline void setLen(INT len) {
                curLen = len;
                if (curMaxLen < len) {
                        curMaxLen = len;
@@ -66,7 +69,7 @@
                }
                assert (array != NULL);
        }
-       inline void setLen(int len,const T &val) {
+       inline void setLen(INT len,const T &val) {
                curLen = len;
                if (curMaxLen < len) {
                        curMaxLen = len;
@@ -76,13 +79,13 @@
                                array = (T*)malloc(curMaxLen*sizeof(T));
                }
                
-               for (int i=0;i<len;++i) {
+               for (INT i=0;i<len;++i) {
                        array[i] = val;
                }
                
                assert (array != NULL);
        }
-       inline void resize(int len) {
+       inline void resize(INT len) {
                curMaxLen = len;
                array = (T*)realloc(array, curMaxLen*sizeof(T));
                assert (array != NULL);
@@ -92,7 +95,7 @@
                if (curLen < curMaxLen)
                        curLen ++; 
                else {
-                       curMaxLen = (int)(curMaxLen*1.3f);
+                       curMaxLen = (INT)(curMaxLen*1.3f);
                        if (array)
                                array = (T*)realloc(array, 
curMaxLen*sizeof(T));
                        else
@@ -114,8 +117,8 @@
                if (curLen < curMaxLen) {
                        array[curLen ++] = data;
                } else {
-                       // fprintf(stderr, "cur:%d, max:%d\n", curLen, 
curMaxLen);
-                       curMaxLen = (int)(curMaxLen*1.3f);
+                       // fprINTf(stderr, "cur:%d, max:%d\n", curLen, 
curMaxLen);
+                       curMaxLen = (INT)(curMaxLen*1.3f);
                        if (array)
                                array = (T*)realloc(array, 
curMaxLen*sizeof(T));
                        else
@@ -133,20 +136,20 @@
                }
        }
 
-       inline T &operator[](int i) { 
+       inline T &operator[](INT i) { 
                //if (array && i < curLen)
                        return array[i];
                //else {
-               //      fprintf(stderr, "VArray(%p)::[] reference out of 
bound (idx:%d size:%d)\n", this, i, curLen);
+               //      fprINTf(stderr, "VArray(%p)::[] reference out of 
bound (idx:%d size:%d)\n", this, i, curLen);
                //      assert(0);
                //      return array[0];
                //}
        }
 
-       inline T & get(int i) {
+       inline T & get(INT i) {
 #ifdef DEBUG_ARRAY
                if (i >= curLen) {
-                       fprintf(stderr, "VArray(%p)::get() reference out of 
bound (%d).\n", this, i);
+                       fprINTf(stderr, "VArray(%p)::get() reference out of 
bound (%d).\n", this, i);
                        assert(0);
                        return array[0];
                }
@@ -154,10 +157,10 @@
                return (*this)[i];
        }
 
-       inline T & _get(int i) {
+       inline T & _get(INT i) {
 #ifdef DEBUG_ARRAY
                if (i >= curLen) {
-                       fprintf(stderr, "VArray(%p)::_get() reference out of 
bound (%d).\n", this, i);
+                       fprINTf(stderr, "VArray(%p)::_get() reference out of 
bound (%d).\n", this, i);
                        assert(0);
                        return array[0];
                }
@@ -165,16 +168,16 @@
                return array[i];
        }
 
-       inline void set(int i, const T& elem) {
+       inline void set(INT i, const T& elem) {
 #ifdef DEBUG_ARRAY
                if (array && i >= curLen) {
-                       fprintf(stderr, "VArray(%p)::set() out of range 
(%d).\n", this, i);
+                       fprINTf(stderr, "VArray(%p)::set() out of range 
(%d).\n", this, i);
                }
 #endif
                array[i] = elem;
        }
 
-       inline void _set(int i, const T& elem) {
+       inline void _set(INT i, const T& elem) {
                array[i] = elem;
        }
 
@@ -188,7 +191,7 @@
        inline T *dupArray() {
                T *ret = (T*)malloc(curLen * sizeof(T));
                if (! ret) {
-                       fprintf(stderr, "Cannot alloc mem in dupArray().\n");
+                       fprINTf(stderr, "Cannot alloc mem in dupArray().\n");
                        return NULL;
                }
                memcpy(ret, array, curLen * sizeof(T));
@@ -213,8 +216,8 @@
 template <class T>
 class VPool : public VArray<T> {
        public:
-       VPool(int size):VArray<T>(size) {}      
-       T& alloc(int * offset=NULL) {
+       VPool(INT size):VArray<T>(size) {}      
+       T& alloc(INT * offset=NULL) {
                append();
                if (offset) *offset = curLen-1;
                return array[curLen-1];

---

• [MANTA] r533 - branches/itanium2/Model/Groups, hansong, 09/06/2005

---

Archive powered by MHonArc 2.6.16.