Changeset 18838 for lang/c/msgpack

Timestamp:

09/04/08 15:52:19 (5 years ago)

Author:

frsyuki

Message:

lang/c/msgpack: optimize zone::alloc()

Location:

lang/c/msgpack/trunk/cpp

Files:

• object.hpp (modified) (3 diffs)
• unpack.cpp (modified) (2 diffs)
• zone.cpp (modified) (4 diffs)
• zone.hpp.erb (modified) (4 diffs)

lang/c/msgpack/trunk/cpp/object.hpp

@@ -70 +70 @@
 struct object_class {
         virtual ~object_class() {}
-        virtual     bool   isnil() const { return false; }
-        virtual     bool   xbool() const { throw cast_error(); }
-        virtual  uint8_t     xu8() const { throw cast_error(); }
-        virtual uint16_t    xu16() const { throw cast_error(); }
-        virtual uint32_t    xu32() const { throw cast_error(); }
-        virtual uint64_t    xu64() const { throw cast_error(); }
-        virtual   int8_t     xi8() const { throw cast_error(); }
-        virtual  int16_t    xi16() const { throw cast_error(); }
-        virtual  int32_t    xi32() const { throw cast_error(); }
-        virtual  int64_t    xi64() const { throw cast_error(); }
-        virtual    float  xfloat() const { throw cast_error(); }
-        virtual   double xdouble() const { throw cast_error(); }
-        virtual      raw    xraw() { throw cast_error(); }
-        virtual   array&  xarray() { throw cast_error(); }
-        virtual     map&    xmap() { throw cast_error(); }
-        virtual    const_raw   xraw() const { throw cast_error(); }
+        virtual bool     isnil  () const { return false; }
+        virtual bool     xbool  () const { throw cast_error(); }
+        virtual uint8_t  xu8    () const { throw cast_error(); }
+        virtual uint16_t xu16   () const { throw cast_error(); }
+        virtual uint32_t xu32   () const { throw cast_error(); }
+        virtual uint64_t xu64   () const { throw cast_error(); }
+        virtual int8_t   xi8    () const { throw cast_error(); }
+        virtual int16_t  xi16   () const { throw cast_error(); }
+        virtual int32_t  xi32   () const { throw cast_error(); }
+        virtual int64_t  xi64   () const { throw cast_error(); }
+        virtual float    xfloat () const { throw cast_error(); }
+        virtual double   xdouble() const { throw cast_error(); }
+        virtual raw      xraw   () { throw cast_error(); }
+        virtual array&   xarray () { throw cast_error(); }
+        virtual map&     xmap   () { throw cast_error(); }
+        virtual const_raw    xraw  () const { throw cast_error(); }
         virtual const array& xarray() const { throw cast_error(); }
-        virtual const   map&   xmap() const { throw cast_error(); }
+        virtual const map&   xmap  () const { throw cast_error(); }
         virtual bool operator== (const object_class* x) const { return false; }
-        bool operator!= (const object_class* x) const { return !(this->operator==(x)); }
         virtual bool operator<  (const object_class* x) const { throw cast_error(); }
         virtual bool operator>  (const object_class* x) const { throw cast_error(); }
+        bool operator!= (const object_class* x) const { return !(this->operator==(x)); }
         virtual void pack(dynamic_packer& p) const = 0;
         operator     bool() const { return   xbool(); } // FIXME !isnil();
@@ -127 +127 @@
         //object(object_class& v) : val(&v) {}
         ~object() {}
-            bool   isnil() const { return val->isnil();   }
-            bool   xbool() const { return val->xbool();   }
-         uint8_t     xu8() const { return val->xu8();     }
-        uint16_t    xu16() const { return val->xu16();    }
-        uint32_t    xu32() const { return val->xu32();    }
-        uint64_t    xu64() const { return val->xu64();    }
-          int8_t     xi8() const { return val->xi8();     }
-         int16_t    xi16() const { return val->xi16();    }
-         int32_t    xi32() const { return val->xi32();    }
-         int64_t    xi64() const { return val->xi64();    }
-           float  xfloat() const { return val->xfloat();  }
-          double xdouble() const { return val->xdouble(); }
-             raw    xraw() { return val->xraw();   }
-          array&  xarray() { return val->xarray(); }
-            map&    xmap() { return val->xmap();   }
-           const_raw   xraw() const { return const_cast<const object_class*>(val)->xraw();   }
+        bool     isnil  () const { return val->isnil();   }
+        bool     xbool  () const { return val->xbool();   }
+        uint8_t  xu8    () const { return val->xu8();     }
+        uint16_t xu16   () const { return val->xu16();    }
+        uint32_t xu32   () const { return val->xu32();    }
+        uint64_t xu64   () const { return val->xu64();    }
+        int8_t   xi8    () const { return val->xi8();     }
+        int16_t  xi16   () const { return val->xi16();    }
+        int32_t  xi32   () const { return val->xi32();    }
+        int64_t  xi64   () const { return val->xi64();    }
+        float    xfloat () const { return val->xfloat();  }
+        double   xdouble() const { return val->xdouble(); }
+        raw      xraw   () { return val->xraw();   }
+        array&   xarray () { return val->xarray(); }
+        map&     xmap   () { return val->xmap();   }
+        const_raw    xraw  () const { return const_cast<const object_class*>(val)->xraw();   }
         const array& xarray() const { return const_cast<const object_class*>(val)->xarray(); }
-        const   map&   xmap() const { return const_cast<const object_class*>(val)->xmap();   }
+        const map&   xmap  () const { return const_cast<const object_class*>(val)->xmap();   }
         bool operator== (object x) const { return val->operator== (x.val); }
         bool operator!= (object x) const { return val->operator!= (x.val); }
@@ -164 +164 @@
         operator array&() { return val->operator array&(); }
         operator   map&() { return val->operator map&();   }
-        operator    raw() const { return val->operator raw();    }
-        operator array&() const { return val->operator array&(); }
-        operator   map&() const { return val->operator map&();   }
+        operator    const_raw() const { return val->operator const_raw();    }
+        operator const array&() const { return val->operator const array&(); }
+        operator const   map&() const { return val->operator const map&();   }
         const object& inspect(std::ostream& s) const
                 { val->inspect(s); return *this; }

lang/c/msgpack/trunk/cpp/unpack.cpp

@@ -21 +21 @@
 
 namespace msgpack {
+
 
 struct unpacker::context {
@@ -99 +100 @@
                 while(next_size < len + m_used) { next_size *= 2; }
 
-                // FIXME realloc?
-                void* tmp = malloc(next_size);
+                void* tmp = realloc(m_buffer, next_size);
                 if(!tmp) { throw std::bad_alloc(); }
-                memcpy(tmp, m_buffer, m_used);
-                free(m_buffer);
+                m_buffer = tmp;
+                //void* tmp = malloc(next_size);
+                //if(!tmp) { throw std::bad_alloc(); }
+                //memcpy(tmp, m_buffer, m_used);
+                //free(m_buffer);
 
                 m_buffer = tmp;

lang/c/msgpack/trunk/cpp/zone.cpp

@@ -21 +21 @@
 
 
-void* zone::alloc()
+// FIXME custom allocator?
+
+void zone::expand_chunk()
 {
-        if(m_pool.size()*ZONE_CHUNK_SIZE <= m_used) {
-                cell_t* chunk = (cell_t*)malloc(sizeof(cell_t)*ZONE_CHUNK_SIZE);
-                if(!chunk) { throw std::bad_alloc(); }
-                try {
-                        m_pool.push_back(chunk);
-                } catch (...) {
-                        free(chunk);
-                        throw;
-                }
+        cell_t* chunk = (cell_t*)malloc(sizeof(cell_t)*ZONE_CHUNK_SIZE);
+        if(!chunk) { throw std::bad_alloc(); }
+        try {
+                m_pool.push_back(chunk);
+        } catch (...) {
+                free(chunk);
+                throw;
         }
-        void* data = m_pool[m_used/ZONE_CHUNK_SIZE][m_used%ZONE_CHUNK_SIZE].data;
-        ++m_used;
-        return data;
 }
 
@@ -41 +38 @@
 {
         if(!m_pool.empty()) {
-                for(size_t b=0; b < m_used/ZONE_CHUNK_SIZE; ++b) {
+                size_t base_size = m_used / ZONE_CHUNK_SIZE;
+                size_t extend_size = m_used % ZONE_CHUNK_SIZE;
+                for(size_t b=0; b < base_size; ++b) {
                         cell_t* c(m_pool[b]);
                         for(size_t e=0; e < ZONE_CHUNK_SIZE; ++e) {
@@ -48 +47 @@
                 }
                 cell_t* c(m_pool.back());
-                for(size_t e=0; e < m_used%ZONE_CHUNK_SIZE; ++e) {
+                for(size_t e=0; e < extend_size; ++e) {
                         reinterpret_cast<object_class*>(c[e].data)->~object_class();
                 }
@@ -61 +60 @@
         m_used = 0;
 
-        for(user_finalizer_t::reverse_iterator it(m_user_finalizer.rbegin()), it_end(m_user_finalizer.rend());
+        for(user_finalizer_t::reverse_iterator it(m_user_finalizer.rbegin()),
+                                        it_end(m_user_finalizer.rend());
                         it != it_end;
                         ++it) {

lang/c/msgpack/trunk/cpp/zone.hpp.erb

@@ -26 +26 @@
 
 #ifndef MSGPACK_ZONE_CHUNK_SIZE
-#define MSGPACK_ZONE_CHUNK_SIZE 8*1024
+#define MSGPACK_ZONE_CHUNK_SIZE 1024
 #endif
 
@@ -45 +45 @@
 
 public:
-           object_nil*    nnil() { return new (alloc()) object_nil();   }
-          object_true*   ntrue() { return new (alloc()) object_true();  }
-         object_false*  nfalse() { return new (alloc()) object_false(); }
-            object_u8*     nu8( uint8_t v) { return new (alloc())     object_u8(v); }
-           object_u16*    nu16(uint16_t v) { return new (alloc())    object_u16(v); }
-           object_u32*    nu32(uint32_t v) { return new (alloc())    object_u32(v); }
-           object_u64*    nu64(uint64_t v) { return new (alloc())    object_u64(v); }
-            object_i8*     ni8(  int8_t v) { return new (alloc())     object_i8(v); }
-           object_i16*    ni16( int16_t v) { return new (alloc())    object_i16(v); }
-           object_i32*    ni32( int32_t v) { return new (alloc())    object_i32(v); }
-           object_i64*    ni64( int64_t v) { return new (alloc())    object_i64(v); }
-         object_float*  nfloat(   float v) { return new (alloc())  object_float(v); }
-        object_double* ndouble(  double v) { return new (alloc()) object_double(v); }
+        object_nil*    nnil   () { return new (alloc()) object_nil();   }
+        object_true*   ntrue  () { return new (alloc()) object_true();  }
+        object_false*  nfalse () { return new (alloc()) object_false(); }
+        object_u8*     nu8    (uint8_t  v) { return new (alloc()) object_u8(v);     }
+        object_u16*    nu16   (uint16_t v) { return new (alloc()) object_u16(v);    }
+        object_u32*    nu32   (uint32_t v) { return new (alloc()) object_u32(v);    }
+        object_u64*    nu64   (uint64_t v) { return new (alloc()) object_u64(v);    }
+        object_i8*     ni8    (int8_t   v) { return new (alloc()) object_i8(v);     }
+        object_i16*    ni16   (int16_t  v) { return new (alloc()) object_i16(v);    }
+        object_i32*    ni32   (int32_t  v) { return new (alloc()) object_i32(v);    }
+        object_i64*    ni64   (int64_t  v) { return new (alloc()) object_i64(v);    }
+        object_float*  nfloat (float    v) { return new (alloc()) object_float(v);  }
+        object_double* ndouble(double   v) { return new (alloc()) object_double(v); }
 
         object_raw_ref* nraw_ref(void* ptr, uint32_t len)
@@ -150 +150 @@
 
 private:
-        void resize_pool(size_t n);
+        void expand_chunk();
 
 public:
@@ -174 +174 @@
 }
 
+inline void* zone::alloc()
+{
+        if(m_pool.size() <= m_used/ZONE_CHUNK_SIZE) {
+                expand_chunk();
+        }
+        void* data = m_pool[m_used/ZONE_CHUNK_SIZE][m_used%ZONE_CHUNK_SIZE].data;
+        ++m_used;
+        return data;
+}
+
 
 }  // namespace msgpack