* array.c (rb_ary_memsize): added.

* io.c (rb_io_memsize): added.
* regcomp.c (onig_memsize): added.
* string.c (rb_str_memsize): added.
* transcode.c (rb_transcoding_memsize, rb_econv_memsize): added.
* variable.c (rb_geneic_ivar_memsize): added.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@23714 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

7 files changed, 113 insertions, 0 deletions

diff --git a/ChangeLog b/ChangeLog
index a6e4908f9f..a3cd2bb010 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
+Wed Jun 17 07:24:26 2009  Koichi Sasada  <ko1@atdot.net>
+
+	* array.c (rb_ary_memsize): added.
+
+	* io.c (rb_io_memsize): added.
+
+	* regcomp.c (onig_memsize): added.
+
+	* string.c (rb_str_memsize): added.
+
+	* transcode.c (rb_transcoding_memsize, rb_econv_memsize): added.
+
+	* variable.c (rb_geneic_ivar_memsize): added.
+
 Wed Jun 17 07:04:33 2009  Koichi Sasada  <ko1@atdot.net>
 
 	* iseq.c (iseq_memsize): added.  Use RTypedData instead of RData
diff --git a/array.c b/array.c
index 3d53bc8ef7..cb37a2ead7 100644
--- a/array.c
+++ b/array.c
@@ -386,6 +386,17 @@ rb_ary_free(VALUE ary)
     }
 }
 
+size_t
+rb_ary_memsize(VALUE ary)
+{
+    if (ARY_OWNS_HEAP_P(ary)) {
+	return RARRAY(ary)->as.heap.aux.capa * sizeof(VALUE);
+    }
+    else {
+	return 0;
+    }
+}
+
 static inline void
 ary_discard(VALUE ary)
 {
diff --git a/io.c b/io.c
index 8f699747bc..75f7abe4a6 100644
--- a/io.c
+++ b/io.c
@@ -3317,6 +3317,20 @@ rb_io_fptr_finalize(rb_io_t *fptr)
     return 1;
 }
 
+size_t rb_econv_memsize(rb_econv_t *);
+
+size_t
+rb_io_memsize(rb_io_t *fptr)
+{
+    size_t size = sizeof(rb_io_t);
+    size += fptr->rbuf_capa;
+    size += fptr->wbuf_capa;
+    size += fptr->cbuf_capa;
+    if (fptr->readconv) size += rb_econv_memsize(fptr->readconv);
+    if (fptr->writeconv) size += rb_econv_memsize(fptr->writeconv);
+    return size;
+}
+
 VALUE
 rb_io_close(VALUE io)
 {
diff --git a/regcomp.c b/regcomp.c
index f24c0c46e3..b8a0723d01 100644
--- a/regcomp.c
+++ b/regcomp.c
@@ -5202,6 +5202,20 @@ onig_free(regex_t* reg)
   }
 }
 
+size_t
+onig_memsize(regex_t *reg)
+{
+    size_t size = sizeof(regex_t);
+    if (IS_NOT_NULL(reg->p))                size += reg->alloc;
+    if (IS_NOT_NULL(reg->exact))            size += reg->exact_end - reg->exact;
+    if (IS_NOT_NULL(reg->int_map))          size += sizeof(int) * ONIG_CHAR_TABLE_SIZE;
+    if (IS_NOT_NULL(reg->int_map_backward)) size += sizeof(int) * ONIG_CHAR_TABLE_SIZE;
+    if (IS_NOT_NULL(reg->repeat_range))     size += reg->repeat_range_alloc * sizeof(OnigRepeatRange);
+    if (IS_NOT_NULL(reg->chain))            size += onig_memsize(reg->chain);
+
+    return size;
+}
+
 #define REGEX_TRANSFER(to,from) do {\
   (to)->state = ONIG_STATE_MODIFY;\
   onig_free_body(to);\
diff --git a/string.c b/string.c
index c9621d399d..7f107c26ad 100644
--- a/string.c
+++ b/string.c
@@ -758,6 +758,17 @@ rb_str_free(VALUE str)
     }
 }
 
+size_t
+rb_str_memsize(VALUE str)
+{
+    if (!STR_EMBED_P(str) && !STR_SHARED_P(str)) {
+	return RSTRING(str)->as.heap.aux.capa;
+    }
+    else {
+	return 0;
+    }
+}
+
 VALUE
 rb_str_to_str(VALUE str)
 {
diff --git a/transcode.c b/transcode.c
index 524ea660dc..7fb25601fc 100644
--- a/transcode.c
+++ b/transcode.c
@@ -798,6 +798,24 @@ rb_transcoding_close(rb_transcoding *tc)
     xfree(tc);
 }
 
+static size_t
+rb_transcoding_memsize(rb_transcoding *tc)
+{
+    size_t size = sizeof(rb_transcoding);
+    const rb_transcoder *tr = tc->transcoder;
+
+    if (TRANSCODING_STATE_EMBED_MAX < tr->state_size) {
+	size += tr->state_size;
+    }
+    if (sizeof(tc->readbuf.ary) < tr->max_input) {
+	size += tr->max_input;
+    }
+    if (sizeof(tc->writebuf.ary) < tr->max_output) {
+	size += tr->max_output;
+    }
+    return size;
+}
+
 static rb_econv_t *
 rb_econv_alloc(int n_hint)
 {
@@ -1663,6 +1681,28 @@ rb_econv_close(rb_econv_t *ec)
     xfree(ec);
 }
 
+size_t
+rb_econv_memsize(rb_econv_t *ec)
+{
+    size_t size = sizeof(rb_econv_t);
+    int i;
+
+    if (ec->replacement_allocated) {
+	size += ec->replacement_len;
+    }
+    for (i = 0; i < ec->num_trans; i++) {
+	size += rb_transcoding_memsize(ec->elems[i].tc);
+
+	if (ec->elems[i].out_buf_start) {
+            size += ec->elems[i].out_buf_end - ec->elems[i].out_buf_start;
+	}
+    }
+    size += ec->in_buf_end - ec->in_buf_start;
+    size += sizeof(rb_econv_elem_t) * ec->num_allocated;
+
+    return size;
+}
+
 int
 rb_econv_putbackable(rb_econv_t *ec)
 {
diff --git a/variable.c b/variable.c
index 7cf15b7b2c..9d360de4da 100644
--- a/variable.c
+++ b/variable.c
@@ -919,6 +919,15 @@ rb_free_generic_ivar(VALUE obj)
 	st_free_table((st_table *)tbl);
 }
 
+size_t
+rb_geneic_ivar_memsize(VALUE obj)
+{
+    st_data_t tbl;
+    if (st_delete(generic_iv_tbl, &obj, &tbl))
+      return st_memsize((st_table *)tbl);
+    return 0;
+}
+
 void
 rb_copy_generic_ivar(VALUE clone, VALUE obj)
 {