diff options
Diffstat (limited to 'jni/ruby/ext/objspace')
| -rw-r--r-- | jni/ruby/ext/objspace/Makefile | 335 | ||||
| -rw-r--r-- | jni/ruby/ext/objspace/depend | 66 | ||||
| -rw-r--r-- | jni/ruby/ext/objspace/extconf.h | 3 | ||||
| -rw-r--r-- | jni/ruby/ext/objspace/extconf.rb | 3 | ||||
| -rw-r--r-- | jni/ruby/ext/objspace/object_tracing.c | 492 | ||||
| -rw-r--r-- | jni/ruby/ext/objspace/objspace.c | 777 | ||||
| -rw-r--r-- | jni/ruby/ext/objspace/objspace.h | 20 | ||||
| -rw-r--r-- | jni/ruby/ext/objspace/objspace_dump.c | 434 |
8 files changed, 2130 insertions, 0 deletions
diff --git a/jni/ruby/ext/objspace/Makefile b/jni/ruby/ext/objspace/Makefile new file mode 100644 index 0000000..a583e14 --- /dev/null +++ b/jni/ruby/ext/objspace/Makefile @@ -0,0 +1,335 @@ + +SHELL = /bin/sh + +# V=0 quiet, V=1 verbose. other values don't work. +V = 0 +Q1 = $(V:1=) +Q = $(Q1:0=@) +ECHO1 = $(V:1=@:) +ECHO = $(ECHO1:0=@echo) +NULLCMD = : + +#### Start of system configuration section. #### +top_srcdir = $(topdir)/. +srcdir = $(top_srcdir)/ext/objspace +topdir = ../.. +hdrdir = $(top_srcdir)/include +arch_hdrdir = $(extout)/include/$(arch) +PATH_SEPARATOR = : +VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby:$(topdir):$(top_srcdir) +RUBYLIB = +RUBYOPT = - +prefix = $(DESTDIR)/usr/local +rubysitearchprefix = $(rubylibprefix)/$(sitearch) +rubyarchprefix = $(rubylibprefix)/$(arch) +rubylibprefix = $(libdir)/$(RUBY_BASE_NAME) +exec_prefix = $(prefix) +vendorarchhdrdir = $(vendorhdrdir)/$(sitearch) +sitearchhdrdir = $(sitehdrdir)/$(sitearch) +rubyarchhdrdir = $(rubyhdrdir)/$(arch) +vendorhdrdir = $(rubyhdrdir)/vendor_ruby +sitehdrdir = $(rubyhdrdir)/site_ruby +rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME) +vendorarchdir = $(vendorlibdir)/$(sitearch) +vendorlibdir = $(vendordir)/$(ruby_version) +vendordir = $(rubylibprefix)/vendor_ruby +sitearchdir = $(sitelibdir)/$(sitearch) +sitelibdir = $(sitedir)/$(ruby_version) +sitedir = $(rubylibprefix)/site_ruby +rubyarchdir = $(rubylibdir)/$(arch) +rubylibdir = $(rubylibprefix)/$(ruby_version) +sitearchincludedir = $(includedir)/$(sitearch) +archincludedir = $(includedir)/$(arch) +sitearchlibdir = $(libdir)/$(sitearch) +archlibdir = $(libdir)/$(arch) +ridir = $(datarootdir)/$(RI_BASE_NAME) +mandir = $(datarootdir)/man +localedir = $(datarootdir)/locale +libdir = $(exec_prefix)/lib +psdir = $(docdir) +pdfdir = $(docdir) +dvidir = $(docdir) +htmldir = $(docdir) +infodir = $(datarootdir)/info +docdir = $(datarootdir)/doc/$(PACKAGE) +oldincludedir = $(DESTDIR)/usr/include +includedir = $(prefix)/include +localstatedir = $(prefix)/var +sharedstatedir = $(prefix)/com +sysconfdir = $(prefix)/etc +datadir = $(datarootdir) +datarootdir = $(prefix)/share +libexecdir = $(exec_prefix)/libexec +sbindir = $(exec_prefix)/sbin +bindir = $(exec_prefix)/bin +archdir = $(rubyarchdir) + + +CC = gcc +CXX = g++ +LIBRUBY = $(LIBRUBY_SO) +LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a +LIBRUBYARG_SHARED = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME) +LIBRUBYARG_STATIC = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static +empty = +OUTFLAG = -o $(empty) +COUTFLAG = -o $(empty) + +RUBY_EXTCONF_H = extconf.h +cflags = $(optflags) $(debugflags) $(warnflags) +optflags = -O3 -fno-fast-math +debugflags = -ggdb3 +warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration -Wdeprecated-declarations -Wno-packed-bitfield-compat +CCDLFLAGS = -fPIC +CFLAGS = $(CCDLFLAGS) $(cflags) -fPIC $(ARCH_FLAG) +INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(srcdir) -I$(topdir) -I$(top_srcdir) +DEFS = +CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\" $(DEFS) $(cppflags) +CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG) +ldflags = -L. -fstack-protector -rdynamic -Wl,-export-dynamic +dldflags = +ARCH_FLAG = +DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG) +LDSHARED = $(CC) -shared +LDSHAREDXX = $(CXX) -shared +AR = ar +EXEEXT = + +RUBY_INSTALL_NAME = $(RUBY_BASE_NAME) +RUBY_SO_NAME = ruby +RUBYW_INSTALL_NAME = +RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version) +RUBYW_BASE_NAME = rubyw +RUBY_BASE_NAME = ruby + +arch = x86_64-linux +sitearch = $(arch) +ruby_version = 2.2.0 +ruby = $(topdir)/miniruby -I'$(topdir)' -I'$(top_srcdir)/lib' -I'$(extout)/$(arch)' -I'$(extout)/common' +RUBY = $(ruby) +ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h $(RUBY_EXTCONF_H) + +RM = rm -f +RM_RF = $(RUBY) -run -e rm -- -rf +RMDIRS = rmdir --ignore-fail-on-non-empty -p +MAKEDIRS = /bin/mkdir -p +INSTALL = /usr/bin/install -c +INSTALL_PROG = $(INSTALL) -m 0755 +INSTALL_DATA = $(INSTALL) -m 644 +COPY = cp +TOUCH = exit > + +#### End of system configuration section. #### + +preload = + +libpath = . $(topdir) +LIBPATH = -L. -L$(topdir) +DEFFILE = + +CLEANFILES = mkmf.log +DISTCLEANFILES = +DISTCLEANDIRS = + +extout = $(topdir)/.ext +extout_prefix = $(extout)$(target_prefix)/ +target_prefix = +LOCAL_LIBS = +LIBS = $(LIBRUBYARG_SHARED) -lpthread -lgmp -ldl -lcrypt -lm -lc +ORIG_SRCS = objspace_dump.c object_tracing.c objspace.c +SRCS = $(ORIG_SRCS) +OBJS = objspace_dump.o object_tracing.o objspace.o +HDRS = $(srcdir)/extconf.h $(srcdir)/objspace.h +TARGET = objspace +TARGET_NAME = objspace +TARGET_ENTRY = Init_$(TARGET_NAME) +DLLIB = $(TARGET).so +EXTSTATIC = +STATIC_LIB = $(TARGET).a + +TIMESTAMP_DIR = $(extout)/.timestamp +BINDIR = $(extout)/bin +RUBYCOMMONDIR = $(extout)/common +RUBYLIBDIR = $(RUBYCOMMONDIR)$(target_prefix) +RUBYARCHDIR = $(extout)/$(arch)$(target_prefix) +HDRDIR = $(extout)/include/ruby$(target_prefix) +ARCHHDRDIR = $(extout)/include/$(arch)/ruby$(target_prefix) + +TARGET_SO = $(RUBYARCHDIR)/$(DLLIB) +CLEANLIBS = $(RUBYARCHDIR)/$(TARGET).so +CLEANOBJS = *.o *.bak + +all: install +static: all +.PHONY: all install static install-so install-rb +.PHONY: clean clean-so clean-static clean-rb + +clean-static:: +clean-rb-default:: +clean-rb:: +clean-so:: +clean: clean-so clean-static clean-rb-default clean-rb + -$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time + +distclean-rb-default:: +distclean-rb:: +distclean-so:: +distclean-static:: +distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb + -$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log + -$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES) + -$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true + +realclean: distclean +install: install-so install-rb + +install-so: $(RUBYARCHDIR)/$(DLLIB) +clean-so:: + -$(Q)$(RM) $(RUBYARCHDIR)/$(DLLIB) + -$(Q)$(RMDIRS) $(RUBYARCHDIR) 2> /dev/null || true +clean-static:: + -$(Q)$(RM) $(STATIC_LIB) +install-rb: pre-install-rb install-rb-default +install-rb-default: pre-install-rb-default +pre-install-rb: Makefile +pre-install-rb-default: Makefile +pre-install-rb-default: + @$(NULLCMD) +$(TIMESTAMP_DIR)/.RUBYARCHDIR.time: + $(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR) + $(Q) $(TOUCH) $@ + +site-install: site-install-so site-install-rb +site-install-so: install-so +site-install-rb: install-rb + +.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S + +.cc.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cc.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.mm.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.mm.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.cxx.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cxx.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.cpp.o: + $(ECHO) compiling $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $< + +.cpp.S: + $(ECHO) translating $(<) + $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $< + +.c.o: + $(ECHO) compiling $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $< + +.c.S: + $(ECHO) translating $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $< + +.m.o: + $(ECHO) compiling $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $< + +.m.S: + $(ECHO) translating $(<) + $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $< + +$(RUBYARCHDIR)/$(DLLIB): $(OBJS) Makefile $(TIMESTAMP_DIR)/.RUBYARCHDIR.time + $(ECHO) linking shared-object $(DLLIB) + -$(Q)$(RM) $(@) + $(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS) + +$(STATIC_LIB): $(OBJS) + -$(Q)$(RM) $(@) + $(ECHO) linking static-library $(@) + $(Q) $(AR) cru $@ $(OBJS) + -$(Q)ranlib $(@) 2> /dev/null || true + +### +$(OBJS): $(RUBY_EXTCONF_H) + +# AUTOGENERATED DEPENDENCIES START +object_tracing.o: $(RUBY_EXTCONF_H) +object_tracing.o: $(arch_hdrdir)/ruby/config.h +object_tracing.o: $(hdrdir)/ruby/debug.h +object_tracing.o: $(hdrdir)/ruby/defines.h +object_tracing.o: $(hdrdir)/ruby/encoding.h +object_tracing.o: $(hdrdir)/ruby/intern.h +object_tracing.o: $(hdrdir)/ruby/io.h +object_tracing.o: $(hdrdir)/ruby/missing.h +object_tracing.o: $(hdrdir)/ruby/oniguruma.h +object_tracing.o: $(hdrdir)/ruby/ruby.h +object_tracing.o: $(hdrdir)/ruby/st.h +object_tracing.o: $(hdrdir)/ruby/subst.h +object_tracing.o: $(top_srcdir)/include/ruby.h +object_tracing.o: $(top_srcdir)/internal.h +object_tracing.o: object_tracing.c +object_tracing.o: objspace.h +objspace.o: $(RUBY_EXTCONF_H) +objspace.o: $(arch_hdrdir)/ruby/config.h +objspace.o: $(hdrdir)/ruby/defines.h +objspace.o: $(hdrdir)/ruby/encoding.h +objspace.o: $(hdrdir)/ruby/intern.h +objspace.o: $(hdrdir)/ruby/io.h +objspace.o: $(hdrdir)/ruby/missing.h +objspace.o: $(hdrdir)/ruby/oniguruma.h +objspace.o: $(hdrdir)/ruby/re.h +objspace.o: $(hdrdir)/ruby/regex.h +objspace.o: $(hdrdir)/ruby/ruby.h +objspace.o: $(hdrdir)/ruby/st.h +objspace.o: $(hdrdir)/ruby/subst.h +objspace.o: $(top_srcdir)/gc.h +objspace.o: $(top_srcdir)/include/ruby.h +objspace.o: $(top_srcdir)/internal.h +objspace.o: $(top_srcdir)/node.h +objspace.o: objspace.c +objspace_dump.o: $(RUBY_EXTCONF_H) +objspace_dump.o: $(arch_hdrdir)/ruby/config.h +objspace_dump.o: $(hdrdir)/ruby/debug.h +objspace_dump.o: $(hdrdir)/ruby/defines.h +objspace_dump.o: $(hdrdir)/ruby/encoding.h +objspace_dump.o: $(hdrdir)/ruby/intern.h +objspace_dump.o: $(hdrdir)/ruby/io.h +objspace_dump.o: $(hdrdir)/ruby/missing.h +objspace_dump.o: $(hdrdir)/ruby/oniguruma.h +objspace_dump.o: $(hdrdir)/ruby/ruby.h +objspace_dump.o: $(hdrdir)/ruby/st.h +objspace_dump.o: $(hdrdir)/ruby/subst.h +objspace_dump.o: $(hdrdir)/ruby/thread_native.h +objspace_dump.o: $(top_srcdir)/ccan/check_type/check_type.h +objspace_dump.o: $(top_srcdir)/ccan/container_of/container_of.h +objspace_dump.o: $(top_srcdir)/ccan/list/list.h +objspace_dump.o: $(top_srcdir)/ccan/str/str.h +objspace_dump.o: $(top_srcdir)/gc.h +objspace_dump.o: $(top_srcdir)/include/ruby.h +objspace_dump.o: $(top_srcdir)/internal.h +objspace_dump.o: $(top_srcdir)/method.h +objspace_dump.o: $(top_srcdir)/node.h +objspace_dump.o: $(top_srcdir)/ruby_atomic.h +objspace_dump.o: $(top_srcdir)/thread_pthread.h +objspace_dump.o: $(top_srcdir)/vm_core.h +objspace_dump.o: $(top_srcdir)/vm_debug.h +objspace_dump.o: $(top_srcdir)/vm_opts.h +objspace_dump.o: objspace.h +objspace_dump.o: objspace_dump.c +objspace_dump.o: id.h +# AUTOGENERATED DEPENDENCIES END diff --git a/jni/ruby/ext/objspace/depend b/jni/ruby/ext/objspace/depend new file mode 100644 index 0000000..32af521 --- /dev/null +++ b/jni/ruby/ext/objspace/depend @@ -0,0 +1,66 @@ +# AUTOGENERATED DEPENDENCIES START +object_tracing.o: $(RUBY_EXTCONF_H) +object_tracing.o: $(arch_hdrdir)/ruby/config.h +object_tracing.o: $(hdrdir)/ruby/debug.h +object_tracing.o: $(hdrdir)/ruby/defines.h +object_tracing.o: $(hdrdir)/ruby/encoding.h +object_tracing.o: $(hdrdir)/ruby/intern.h +object_tracing.o: $(hdrdir)/ruby/io.h +object_tracing.o: $(hdrdir)/ruby/missing.h +object_tracing.o: $(hdrdir)/ruby/oniguruma.h +object_tracing.o: $(hdrdir)/ruby/ruby.h +object_tracing.o: $(hdrdir)/ruby/st.h +object_tracing.o: $(hdrdir)/ruby/subst.h +object_tracing.o: $(top_srcdir)/include/ruby.h +object_tracing.o: $(top_srcdir)/internal.h +object_tracing.o: object_tracing.c +object_tracing.o: objspace.h +objspace.o: $(RUBY_EXTCONF_H) +objspace.o: $(arch_hdrdir)/ruby/config.h +objspace.o: $(hdrdir)/ruby/defines.h +objspace.o: $(hdrdir)/ruby/encoding.h +objspace.o: $(hdrdir)/ruby/intern.h +objspace.o: $(hdrdir)/ruby/io.h +objspace.o: $(hdrdir)/ruby/missing.h +objspace.o: $(hdrdir)/ruby/oniguruma.h +objspace.o: $(hdrdir)/ruby/re.h +objspace.o: $(hdrdir)/ruby/regex.h +objspace.o: $(hdrdir)/ruby/ruby.h +objspace.o: $(hdrdir)/ruby/st.h +objspace.o: $(hdrdir)/ruby/subst.h +objspace.o: $(top_srcdir)/gc.h +objspace.o: $(top_srcdir)/include/ruby.h +objspace.o: $(top_srcdir)/internal.h +objspace.o: $(top_srcdir)/node.h +objspace.o: objspace.c +objspace_dump.o: $(RUBY_EXTCONF_H) +objspace_dump.o: $(arch_hdrdir)/ruby/config.h +objspace_dump.o: $(hdrdir)/ruby/debug.h +objspace_dump.o: $(hdrdir)/ruby/defines.h +objspace_dump.o: $(hdrdir)/ruby/encoding.h +objspace_dump.o: $(hdrdir)/ruby/intern.h +objspace_dump.o: $(hdrdir)/ruby/io.h +objspace_dump.o: $(hdrdir)/ruby/missing.h +objspace_dump.o: $(hdrdir)/ruby/oniguruma.h +objspace_dump.o: $(hdrdir)/ruby/ruby.h +objspace_dump.o: $(hdrdir)/ruby/st.h +objspace_dump.o: $(hdrdir)/ruby/subst.h +objspace_dump.o: $(hdrdir)/ruby/thread_native.h +objspace_dump.o: $(top_srcdir)/ccan/check_type/check_type.h +objspace_dump.o: $(top_srcdir)/ccan/container_of/container_of.h +objspace_dump.o: $(top_srcdir)/ccan/list/list.h +objspace_dump.o: $(top_srcdir)/ccan/str/str.h +objspace_dump.o: $(top_srcdir)/gc.h +objspace_dump.o: $(top_srcdir)/include/ruby.h +objspace_dump.o: $(top_srcdir)/internal.h +objspace_dump.o: $(top_srcdir)/method.h +objspace_dump.o: $(top_srcdir)/node.h +objspace_dump.o: $(top_srcdir)/ruby_atomic.h +objspace_dump.o: $(top_srcdir)/thread_pthread.h +objspace_dump.o: $(top_srcdir)/vm_core.h +objspace_dump.o: $(top_srcdir)/vm_debug.h +objspace_dump.o: $(top_srcdir)/vm_opts.h +objspace_dump.o: objspace.h +objspace_dump.o: objspace_dump.c +objspace_dump.o: {$(VPATH)}id.h +# AUTOGENERATED DEPENDENCIES END diff --git a/jni/ruby/ext/objspace/extconf.h b/jni/ruby/ext/objspace/extconf.h new file mode 100644 index 0000000..cda0cc8 --- /dev/null +++ b/jni/ruby/ext/objspace/extconf.h @@ -0,0 +1,3 @@ +#ifndef EXTCONF_H +#define EXTCONF_H +#endif diff --git a/jni/ruby/ext/objspace/extconf.rb b/jni/ruby/ext/objspace/extconf.rb new file mode 100644 index 0000000..2b41543 --- /dev/null +++ b/jni/ruby/ext/objspace/extconf.rb @@ -0,0 +1,3 @@ +$INCFLAGS << " -I$(topdir) -I$(top_srcdir)" +$VPATH << '$(topdir)' << '$(top_srcdir)' # for id.h. +create_makefile('objspace') diff --git a/jni/ruby/ext/objspace/object_tracing.c b/jni/ruby/ext/objspace/object_tracing.c new file mode 100644 index 0000000..3a7f544 --- /dev/null +++ b/jni/ruby/ext/objspace/object_tracing.c @@ -0,0 +1,492 @@ +/********************************************************************** + + object_tracing.c - Object Tracing mechanism/ObjectSpace extender for MRI. + + $Author$ + created at: Mon May 27 16:27:44 2013 + + NOTE: This extension library is not expected to exist except C Ruby. + NOTE: This feature is an example usage of internal event tracing APIs. + + All the files in this distribution are covered under the Ruby's + license (see the file COPYING). + +**********************************************************************/ + +#include "internal.h" +#include "ruby/debug.h" +#include "objspace.h" + +struct traceobj_arg { + int running; + int keep_remains; + VALUE newobj_trace; + VALUE freeobj_trace; + st_table *object_table; /* obj (VALUE) -> allocation_info */ + st_table *str_table; /* cstr -> refcount */ + struct traceobj_arg *prev_traceobj_arg; +}; + +static const char * +make_unique_str(st_table *tbl, const char *str, long len) +{ + if (!str) { + return NULL; + } + else { + st_data_t n; + char *result; + + if (st_lookup(tbl, (st_data_t)str, &n)) { + st_insert(tbl, (st_data_t)str, n+1); + st_get_key(tbl, (st_data_t)str, (st_data_t *)&result); + } + else { + result = (char *)ruby_xmalloc(len+1); + strncpy(result, str, len); + result[len] = 0; + st_add_direct(tbl, (st_data_t)result, 1); + } + return result; + } +} + +static void +delete_unique_str(st_table *tbl, const char *str) +{ + if (str) { + st_data_t n; + + st_lookup(tbl, (st_data_t)str, &n); + if (n == 1) { + st_delete(tbl, (st_data_t *)&str, 0); + ruby_xfree((char *)str); + } + else { + st_insert(tbl, (st_data_t)str, n-1); + } + } +} + +static void +newobj_i(VALUE tpval, void *data) +{ + struct traceobj_arg *arg = (struct traceobj_arg *)data; + rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval); + VALUE obj = rb_tracearg_object(tparg); + VALUE path = rb_tracearg_path(tparg); + VALUE line = rb_tracearg_lineno(tparg); + VALUE mid = rb_tracearg_method_id(tparg); + VALUE klass = rb_tracearg_defined_class(tparg); + struct allocation_info *info; + const char *path_cstr = RTEST(path) ? make_unique_str(arg->str_table, RSTRING_PTR(path), RSTRING_LEN(path)) : 0; + VALUE class_path = (RTEST(klass) && !OBJ_FROZEN(klass)) ? rb_class_path_cached(klass) : Qnil; + const char *class_path_cstr = RTEST(class_path) ? make_unique_str(arg->str_table, RSTRING_PTR(class_path), RSTRING_LEN(class_path)) : 0; + + if (st_lookup(arg->object_table, (st_data_t)obj, (st_data_t *)&info)) { + if (arg->keep_remains) { + if (info->living) { + /* do nothing. there is possibility to keep living if FREEOBJ events while suppressing tracing */ + } + } + /* reuse info */ + delete_unique_str(arg->str_table, info->path); + delete_unique_str(arg->str_table, info->class_path); + } + else { + info = (struct allocation_info *)ruby_xmalloc(sizeof(struct allocation_info)); + } + info->living = 1; + info->flags = RBASIC(obj)->flags; + info->klass = RBASIC_CLASS(obj); + + info->path = path_cstr; + info->line = NUM2INT(line); + info->mid = mid; + info->class_path = class_path_cstr; + info->generation = rb_gc_count(); + st_insert(arg->object_table, (st_data_t)obj, (st_data_t)info); +} + +static void +freeobj_i(VALUE tpval, void *data) +{ + struct traceobj_arg *arg = (struct traceobj_arg *)data; + rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval); + VALUE obj = rb_tracearg_object(tparg); + struct allocation_info *info; + + if (st_lookup(arg->object_table, (st_data_t)obj, (st_data_t *)&info)) { + if (arg->keep_remains) { + info->living = 0; + } + else { + st_delete(arg->object_table, (st_data_t *)&obj, (st_data_t *)&info); + delete_unique_str(arg->str_table, info->path); + delete_unique_str(arg->str_table, info->class_path); + ruby_xfree(info); + } + } +} + +static int +free_keys_i(st_data_t key, st_data_t value, void *data) +{ + ruby_xfree((void *)key); + return ST_CONTINUE; +} + +static int +free_values_i(st_data_t key, st_data_t value, void *data) +{ + ruby_xfree((void *)value); + return ST_CONTINUE; +} + +static struct traceobj_arg *tmp_trace_arg; /* TODO: Do not use global variables */ +static int tmp_keep_remains; /* TODO: Do not use global variables */ + +static struct traceobj_arg * +get_traceobj_arg(void) +{ + if (tmp_trace_arg == 0) { + tmp_trace_arg = ALLOC_N(struct traceobj_arg, 1); + tmp_trace_arg->running = 0; + tmp_trace_arg->keep_remains = tmp_keep_remains; + tmp_trace_arg->newobj_trace = 0; + tmp_trace_arg->freeobj_trace = 0; + tmp_trace_arg->object_table = st_init_numtable(); + tmp_trace_arg->str_table = st_init_strtable(); + } + return tmp_trace_arg; +} + +/* + * call-seq: trace_object_allocations_start + * + * Starts tracing object allocations. + * + */ +static VALUE +trace_object_allocations_start(VALUE self) +{ + struct traceobj_arg *arg = get_traceobj_arg(); + + if (arg->running++ > 0) { + /* do nothing */ + } + else { + if (arg->newobj_trace == 0) { + arg->newobj_trace = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, arg); + arg->freeobj_trace = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, arg); + } + rb_tracepoint_enable(arg->newobj_trace); + rb_tracepoint_enable(arg->freeobj_trace); + } + + return Qnil; +} + +/* + * call-seq: trace_object_allocations_stop + * + * Stop tracing object allocations. + * + * Note that if ::trace_object_allocations_start is called n-times, then + * tracing will stop after calling ::trace_object_allocations_stop n-times. + * + */ +static VALUE +trace_object_allocations_stop(VALUE self) +{ + struct traceobj_arg *arg = get_traceobj_arg(); + + if (arg->running > 0) { + arg->running--; + } + + if (arg->running == 0) { + rb_tracepoint_disable(arg->newobj_trace); + rb_tracepoint_disable(arg->freeobj_trace); + arg->newobj_trace = 0; + arg->freeobj_trace = 0; + } + + return Qnil; +} + +/* + * call-seq: trace_object_allocations_clear + * + * Clear recorded tracing information. + * + */ +static VALUE +trace_object_allocations_clear(VALUE self) +{ + struct traceobj_arg *arg = get_traceobj_arg(); + + /* clear tables */ + st_foreach(arg->object_table, free_values_i, 0); + st_clear(arg->object_table); + st_foreach(arg->str_table, free_keys_i, 0); + st_clear(arg->str_table); + + /* do not touch TracePoints */ + + return Qnil; +} + +/* + * call-seq: trace_object_allocations { block } + * + * Starts tracing object allocations from the ObjectSpace extension module. + * + * For example: + * + * require 'objspace' + * + * class C + * include ObjectSpace + * + * def foo + * trace_object_allocations do + * obj = Object.new + * p "#{allocation_sourcefile(obj)}:#{allocation_sourceline(obj)}" + * end + * end + * end + * + * C.new.foo #=> "objtrace.rb:8" + * + * This example has included the ObjectSpace module to make it easier to read, + * but you can also use the ::trace_object_allocations notation (recommended). + * + * Note that this feature introduces a huge performance decrease and huge + * memory consumption. + */ +static VALUE +trace_object_allocations(VALUE self) +{ + trace_object_allocations_start(self); + return rb_ensure(rb_yield, Qnil, trace_object_allocations_stop, self); +} + +int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data); +static int object_allocations_reporter_registered = 0; + +static int +object_allocations_reporter_i(st_data_t key, st_data_t val, st_data_t ptr) +{ + FILE *out = (FILE *)ptr; + VALUE obj = (VALUE)key; + struct allocation_info *info = (struct allocation_info *)val; + + fprintf(out, "-- %p (%s F: %p, ", (void *)obj, info->living ? "live" : "dead", (void *)info->flags); + if (info->class_path) fprintf(out, "C: %s", info->class_path); + else fprintf(out, "C: %p", (void *)info->klass); + fprintf(out, "@%s:%lu", info->path ? info->path : "", info->line); + if (!NIL_P(info->mid)) { + VALUE m = rb_sym2str(info->mid); + fprintf(out, " (%s)", RSTRING_PTR(m)); + } + fprintf(out, ")\n"); + + return ST_CONTINUE; +} + +static void +object_allocations_reporter(FILE *out, void *ptr) +{ + fprintf(out, "== object_allocations_reporter: START\n"); + if (tmp_trace_arg) { + st_foreach(tmp_trace_arg->object_table, object_allocations_reporter_i, (st_data_t)out); + } + fprintf(out, "== object_allocations_reporter: END\n"); +} + +static VALUE +trace_object_allocations_debug_start(VALUE self) +{ + tmp_keep_remains = 1; + if (object_allocations_reporter_registered == 0) { + object_allocations_reporter_registered = 1; + rb_bug_reporter_add(object_allocations_reporter, 0); + } + + return trace_object_allocations_start(self); +} + +static struct allocation_info * +lookup_allocation_info(VALUE obj) +{ + if (tmp_trace_arg) { + struct allocation_info *info; + if (st_lookup(tmp_trace_arg->object_table, obj, (st_data_t *)&info)) { + return info; + } + } + return NULL; +} + +struct allocation_info * +objspace_lookup_allocation_info(VALUE obj) +{ + return lookup_allocation_info(obj); +} + +/* + * call-seq: allocation_sourcefile(object) -> string + * + * Returns the source file origin from the given +object+. + * + * See ::trace_object_allocations for more information and examples. + */ +static VALUE +allocation_sourcefile(VALUE self, VALUE obj) +{ + struct allocation_info *info = lookup_allocation_info(obj); + + if (info && info->path) { + return rb_str_new2(info->path); + } + else { + return Qnil; + } +} + +/* + * call-seq: allocation_sourceline(object) -> string + * + * Returns the original line from source for from the given +object+. + * + * See ::trace_object_allocations for more information and examples. + */ +static VALUE +allocation_sourceline(VALUE self, VALUE obj) +{ + struct allocation_info *info = lookup_allocation_info(obj); + + if (info) { + return INT2FIX(info->line); + } + else { + return Qnil; + } +} + +/* + * call-seq: allocation_class_path(object) -> string + * + * Returns the class for the given +object+. + * + * class A + * def foo + * ObjectSpace::trace_object_allocations do + * obj = Object.new + * p "#{ObjectSpace::allocation_class_path(obj)}" + * end + * end + * end + * + * A.new.foo #=> "Class" + * + * See ::trace_object_allocations for more information and examples. + */ +static VALUE +allocation_class_path(VALUE self, VALUE obj) +{ + struct allocation_info *info = lookup_allocation_info(obj); + + if (info && info->class_path) { + return rb_str_new2(info->class_path); + } + else { + return Qnil; + } +} + +/* + * call-seq: allocation_method_id(object) -> string + * + * Returns the method identifier for the given +object+. + * + * class A + * include ObjectSpace + * + * def foo + * trace_object_allocations do + * obj = Object.new + * p "#{allocation_class_path(obj)}##{allocation_method_id(obj)}" + * end + * end + * end + * + * A.new.foo #=> "Class#new" + * + * See ::trace_object_allocations for more information and examples. + */ +static VALUE +allocation_method_id(VALUE self, VALUE obj) +{ + struct allocation_info *info = lookup_allocation_info(obj); + if (info) { + return info->mid; + } + else { + return Qnil; + } +} + +/* + * call-seq: allocation_generation(object) -> Fixnum + * + * Returns garbage collector generation for the given +object+. + * + * class B + * include ObjectSpace + * + * def foo + * trace_object_allocations do + * obj = Object.new + * p "Generation is #{allocation_generation(obj)}" + * end + * end + * end + * + * B.new.foo #=> "Generation is 3" + * + * See ::trace_object_allocations for more information and examples. + */ +static VALUE +allocation_generation(VALUE self, VALUE obj) +{ + struct allocation_info *info = lookup_allocation_info(obj); + if (info) { + return SIZET2NUM(info->generation); + } + else { + return Qnil; + } +} + +void +Init_object_tracing(VALUE rb_mObjSpace) +{ +#if 0 + rb_mObjSpace = rb_define_module("ObjectSpace"); /* let rdoc know */ +#endif + + rb_define_module_function(rb_mObjSpace, "trace_object_allocations", trace_object_allocations, 0); + rb_define_module_function(rb_mObjSpace, "trace_object_allocations_start", trace_object_allocations_start, 0); + rb_define_module_function(rb_mObjSpace, "trace_object_allocations_stop", trace_object_allocations_stop, 0); + rb_define_module_function(rb_mObjSpace, "trace_object_allocations_clear", trace_object_allocations_clear, 0); + + rb_define_module_function(rb_mObjSpace, "trace_object_allocations_debug_start", trace_object_allocations_debug_start, 0); + + rb_define_module_function(rb_mObjSpace, "allocation_sourcefile", allocation_sourcefile, 1); + rb_define_module_function(rb_mObjSpace, "allocation_sourceline", allocation_sourceline, 1); + rb_define_module_function(rb_mObjSpace, "allocation_class_path", allocation_class_path, 1); + rb_define_module_function(rb_mObjSpace, "allocation_method_id", allocation_method_id, 1); + rb_define_module_function(rb_mObjSpace, "allocation_generation", allocation_generation, 1); +} diff --git a/jni/ruby/ext/objspace/objspace.c b/jni/ruby/ext/objspace/objspace.c new file mode 100644 index 0000000..5f5a79b --- /dev/null +++ b/jni/ruby/ext/objspace/objspace.c @@ -0,0 +1,777 @@ +/********************************************************************** + + objspace.c - ObjectSpace extender for MRI. + + $Author: ko1 $ + created at: Wed Jun 17 07:39:17 2009 + + NOTE: This extension library is only expected to exist with C Ruby. + + All the files in this distribution are covered under the Ruby's + license (see the file COPYING). + +**********************************************************************/ + +#include "internal.h" +#include <ruby/st.h> +#include <ruby/io.h> +#include <ruby/re.h> +#include "node.h" +#include "gc.h" + +/* + * call-seq: + * ObjectSpace.memsize_of(obj) -> Integer + * + * Return consuming memory size of obj. + * + * Note that the return size is incomplete. You need to deal with this + * information as only a *HINT*. Especially, the size of +T_DATA+ may not be + * correct. + * + * This method is only expected to work with C Ruby. + * + * From Ruby 2.2, memsize_of(obj) returns a memory size includes + * sizeof(RVALUE). + */ + +static VALUE +memsize_of_m(VALUE self, VALUE obj) +{ + return SIZET2NUM(rb_obj_memsize_of(obj)); +} + +struct total_data { + size_t total; + VALUE klass; +}; + +static int +total_i(void *vstart, void *vend, size_t stride, void *ptr) +{ + VALUE v; + struct total_data *data = (struct total_data *)ptr; + + for (v = (VALUE)vstart; v != (VALUE)vend; v += stride) { + if (RBASIC(v)->flags) { + switch (BUILTIN_TYPE(v)) { + case T_NONE: + case T_ICLASS: + case T_NODE: + case T_ZOMBIE: + continue; + case T_CLASS: + if (FL_TEST(v, FL_SINGLETON)) + continue; + default: + if (data->klass == 0 || rb_obj_is_kind_of(v, data->klass)) { + data->total += rb_obj_memsize_of(v); + } + } + } + } + + return 0; +} + +/* + * call-seq: + * ObjectSpace.memsize_of_all([klass]) -> Integer + * + * Return consuming memory size of all living objects. + * + * If +klass+ (should be Class object) is given, return the total memory size + * of instances of the given class. + * + * Note that the returned size is incomplete. You need to deal with this + * information as only a *HINT*. Especially, the size of +T_DATA+ may not be + * correct. + * + * Note that this method does *NOT* return total malloc'ed memory size. + * + * This method can be defined by the following Ruby code: + * + * def memsize_of_all klass = false + * total = 0 + * ObjectSpace.each_object{|e| + * total += ObjectSpace.memsize_of(e) if klass == false || e.kind_of?(klass) + * } + * total + * end + * + * This method is only expected to work with C Ruby. + */ + +static VALUE +memsize_of_all_m(int argc, VALUE *argv, VALUE self) +{ + struct total_data data = {0, 0}; + + if (argc > 0) { + rb_scan_args(argc, argv, "01", &data.klass); + } + + rb_objspace_each_objects(total_i, &data); + return SIZET2NUM(data.total); +} + +static int +set_zero_i(st_data_t key, st_data_t val, st_data_t arg) +{ + VALUE k = (VALUE)key; + VALUE hash = (VALUE)arg; + rb_hash_aset(hash, k, INT2FIX(0)); + return ST_CONTINUE; +} + +static int +cos_i(void *vstart, void *vend, size_t stride, void *data) +{ + size_t *counts = (size_t *)data; + VALUE v = (VALUE)vstart; + + for (;v != (VALUE)vend; v += stride) { + if (RBASIC(v)->flags) { + counts[BUILTIN_TYPE(v)] += rb_obj_memsize_of(v); + } + } + return 0; +} + +static VALUE +type2sym(enum ruby_value_type i) +{ + VALUE type; + switch (i) { +#define CASE_TYPE(t) case t: type = ID2SYM(rb_intern(#t)); break; + CASE_TYPE(T_NONE); + CASE_TYPE(T_OBJECT); + CASE_TYPE(T_CLASS); + CASE_TYPE(T_MODULE); + CASE_TYPE(T_FLOAT); + CASE_TYPE(T_STRING); + CASE_TYPE(T_REGEXP); + CASE_TYPE(T_ARRAY); + CASE_TYPE(T_HASH); + CASE_TYPE(T_STRUCT); + CASE_TYPE(T_BIGNUM); + CASE_TYPE(T_FILE); + CASE_TYPE(T_DATA); + CASE_TYPE(T_MATCH); + CASE_TYPE(T_COMPLEX); + CASE_TYPE(T_RATIONAL); + CASE_TYPE(T_NIL); + CASE_TYPE(T_TRUE); + CASE_TYPE(T_FALSE); + CASE_TYPE(T_SYMBOL); + CASE_TYPE(T_FIXNUM); + CASE_TYPE(T_UNDEF); + CASE_TYPE(T_NODE); + CASE_TYPE(T_ICLASS); + CASE_TYPE(T_ZOMBIE); +#undef CASE_TYPE + default: rb_bug("type2sym: unknown type (%d)", i); + } + return type; +} + +/* + * call-seq: + * ObjectSpace.count_objects_size([result_hash]) -> hash + * + * Counts objects size (in bytes) for each type. + * + * Note that this information is incomplete. You need to deal with + * this information as only a *HINT*. Especially, total size of + * T_DATA may not right size. + * + * It returns a hash as: + * {:TOTAL=>1461154, :T_CLASS=>158280, :T_MODULE=>20672, :T_STRING=>527249, ...} + * + * If the optional argument, result_hash, is given, + * it is overwritten and returned. + * This is intended to avoid probe effect. + * + * The contents of the returned hash is implementation defined. + * It may be changed in future. + * + * This method is only expected to work with C Ruby. + */ + +static VALUE +count_objects_size(int argc, VALUE *argv, VALUE os) +{ + size_t counts[T_MASK+1]; + size_t total = 0; + enum ruby_value_type i; + VALUE hash; + + if (rb_scan_args(argc, argv, "01", &hash) == 1) { + if (!RB_TYPE_P(hash, T_HASH)) + rb_raise(rb_eTypeError, "non-hash given"); + } + + for (i = 0; i <= T_MASK; i++) { + counts[i] = 0; + } + + rb_objspace_each_objects(cos_i, &counts[0]); + + if (hash == Qnil) { + hash = rb_hash_new(); + } + else if (!RHASH_EMPTY_P(hash)) { + st_foreach(RHASH_TBL(hash), set_zero_i, hash); + } + + for (i = 0; i <= T_MASK; i++) { + if (counts[i]) { + VALUE type = type2sym(i); + total += counts[i]; + rb_hash_aset(hash, type, SIZET2NUM(counts[i])); + } + } + rb_hash_aset(hash, ID2SYM(rb_intern("TOTAL")), SIZET2NUM(total)); + return hash; +} + +static int +cn_i(void *vstart, void *vend, size_t stride, void *n) +{ + size_t *nodes = (size_t *)n; + VALUE v = (VALUE)vstart; + + for (; v != (VALUE)vend; v += stride) { + if (RBASIC(v)->flags && BUILTIN_TYPE(v) == T_NODE) { + size_t s = nd_type((NODE *)v); + nodes[s]++; + } + } + + return 0; +} + +/* + * call-seq: + * ObjectSpace.count_nodes([result_hash]) -> hash + * + * Counts nodes for each node type. + * + * This method is only for MRI developers interested in performance and memory + * usage of Ruby programs. + * + * It returns a hash as: + * + * {:NODE_METHOD=>2027, :NODE_FBODY=>1927, :NODE_CFUNC=>1798, ...} + * + * If the optional argument, result_hash, is given, it is overwritten and + * returned. This is intended to avoid probe effect. + * + * Note: + * The contents of the returned hash is implementation defined. + * It may be changed in future. + * + * This method is only expected to work with C Ruby. + */ + +static VALUE +count_nodes(int argc, VALUE *argv, VALUE os) +{ + size_t nodes[NODE_LAST+1]; + size_t i; + VALUE hash; + + if (rb_scan_args(argc, argv, "01", &hash) == 1) { + if (!RB_TYPE_P(hash, T_HASH)) + rb_raise(rb_eTypeError, "non-hash given"); + } + + for (i = 0; i <= NODE_LAST; i++) { + nodes[i] = 0; + } + + rb_objspace_each_objects(cn_i, &nodes[0]); + + if (hash == Qnil) { + hash = rb_hash_new(); + } + else if (!RHASH_EMPTY_P(hash)) { + st_foreach(RHASH_TBL(hash), set_zero_i, hash); + } + + for (i=0; i<NODE_LAST; i++) { + if (nodes[i] != 0) { + VALUE node; + switch (i) { +#define COUNT_NODE(n) case n: node = ID2SYM(rb_intern(#n)); break; + COUNT_NODE(NODE_SCOPE); + COUNT_NODE(NODE_BLOCK); + COUNT_NODE(NODE_IF); + COUNT_NODE(NODE_CASE); + COUNT_NODE(NODE_WHEN); + COUNT_NODE(NODE_OPT_N); + COUNT_NODE(NODE_WHILE); + COUNT_NODE(NODE_UNTIL); + COUNT_NODE(NODE_ITER); + COUNT_NODE(NODE_FOR); + COUNT_NODE(NODE_BREAK); + COUNT_NODE(NODE_NEXT); + COUNT_NODE(NODE_REDO); + COUNT_NODE(NODE_RETRY); + COUNT_NODE(NODE_BEGIN); + COUNT_NODE(NODE_RESCUE); + COUNT_NODE(NODE_RESBODY); + COUNT_NODE(NODE_ENSURE); + COUNT_NODE(NODE_AND); + COUNT_NODE(NODE_OR); + COUNT_NODE(NODE_MASGN); + COUNT_NODE(NODE_LASGN); + COUNT_NODE(NODE_DASGN); + COUNT_NODE(NODE_DASGN_CURR); + COUNT_NODE(NODE_GASGN); + COUNT_NODE(NODE_IASGN); + COUNT_NODE(NODE_IASGN2); + COUNT_NODE(NODE_CDECL); + COUNT_NODE(NODE_CVASGN); + COUNT_NODE(NODE_CVDECL); + COUNT_NODE(NODE_OP_ASGN1); + COUNT_NODE(NODE_OP_ASGN2); + COUNT_NODE(NODE_OP_ASGN_AND); + COUNT_NODE(NODE_OP_ASGN_OR); + COUNT_NODE(NODE_OP_CDECL); + COUNT_NODE(NODE_CALL); + COUNT_NODE(NODE_FCALL); + COUNT_NODE(NODE_VCALL); + COUNT_NODE(NODE_SUPER); + COUNT_NODE(NODE_ZSUPER); + COUNT_NODE(NODE_ARRAY); + COUNT_NODE(NODE_ZARRAY); + COUNT_NODE(NODE_VALUES); + COUNT_NODE(NODE_HASH); + COUNT_NODE(NODE_RETURN); + COUNT_NODE(NODE_YIELD); + COUNT_NODE(NODE_LVAR); + COUNT_NODE(NODE_DVAR); + COUNT_NODE(NODE_GVAR); + COUNT_NODE(NODE_IVAR); + COUNT_NODE(NODE_CONST); + COUNT_NODE(NODE_CVAR); + COUNT_NODE(NODE_NTH_REF); + COUNT_NODE(NODE_BACK_REF); + COUNT_NODE(NODE_MATCH); + COUNT_NODE(NODE_MATCH2); + COUNT_NODE(NODE_MATCH3); + COUNT_NODE(NODE_LIT); + COUNT_NODE(NODE_STR); + COUNT_NODE(NODE_DSTR); + COUNT_NODE(NODE_XSTR); + COUNT_NODE(NODE_DXSTR); + COUNT_NODE(NODE_EVSTR); + COUNT_NODE(NODE_DREGX); + COUNT_NODE(NODE_DREGX_ONCE); + COUNT_NODE(NODE_ARGS); + COUNT_NODE(NODE_ARGS_AUX); + COUNT_NODE(NODE_OPT_ARG); + COUNT_NODE(NODE_KW_ARG); + COUNT_NODE(NODE_POSTARG); + COUNT_NODE(NODE_ARGSCAT); + COUNT_NODE(NODE_ARGSPUSH); + COUNT_NODE(NODE_SPLAT); + COUNT_NODE(NODE_TO_ARY); + COUNT_NODE(NODE_BLOCK_ARG); + COUNT_NODE(NODE_BLOCK_PASS); + COUNT_NODE(NODE_DEFN); + COUNT_NODE(NODE_DEFS); + COUNT_NODE(NODE_ALIAS); + COUNT_NODE(NODE_VALIAS); + COUNT_NODE(NODE_UNDEF); + COUNT_NODE(NODE_CLASS); + COUNT_NODE(NODE_MODULE); + COUNT_NODE(NODE_SCLASS); + COUNT_NODE(NODE_COLON2); + COUNT_NODE(NODE_COLON3); + COUNT_NODE(NODE_CREF); + COUNT_NODE(NODE_DOT2); + COUNT_NODE(NODE_DOT3); + COUNT_NODE(NODE_FLIP2); + COUNT_NODE(NODE_FLIP3); + COUNT_NODE(NODE_SELF); + COUNT_NODE(NODE_NIL); + COUNT_NODE(NODE_TRUE); + COUNT_NODE(NODE_FALSE); + COUNT_NODE(NODE_ERRINFO); + COUNT_NODE(NODE_DEFINED); + COUNT_NODE(NODE_POSTEXE); + COUNT_NODE(NODE_ALLOCA); + COUNT_NODE(NODE_BMETHOD); + COUNT_NODE(NODE_MEMO); + COUNT_NODE(NODE_IFUNC); + COUNT_NODE(NODE_DSYM); + COUNT_NODE(NODE_ATTRASGN); + COUNT_NODE(NODE_PRELUDE); + COUNT_NODE(NODE_LAMBDA); +#undef COUNT_NODE + default: node = INT2FIX(i); + } + rb_hash_aset(hash, node, SIZET2NUM(nodes[i])); + } + } + return hash; +} + +static int +cto_i(void *vstart, void *vend, size_t stride, void *data) +{ + VALUE hash = (VALUE)data; + VALUE v = (VALUE)vstart; + + for (; v != (VALUE)vend; v += stride) { + if (RBASIC(v)->flags && BUILTIN_TYPE(v) == T_DATA) { + VALUE counter; + VALUE key = RBASIC(v)->klass; + + if (key == 0) { + const char *name = rb_objspace_data_type_name(v); + if (name == 0) name = "unknown"; + key = ID2SYM(rb_intern(name)); + } + + counter = rb_hash_aref(hash, key); + if (NIL_P(counter)) { + counter = INT2FIX(1); + } + else { + counter = INT2FIX(FIX2INT(counter) + 1); + } + + rb_hash_aset(hash, key, counter); + } + } + + return 0; +} + +/* + * call-seq: + * ObjectSpace.count_tdata_objects([result_hash]) -> hash + * + * Counts objects for each +T_DATA+ type. + * + * This method is only for MRI developers interested in performance and memory + * usage of Ruby programs. + * + * It returns a hash as: + * + * {RubyVM::InstructionSequence=>504, :parser=>5, :barrier=>6, + * :mutex=>6, Proc=>60, RubyVM::Env=>57, Mutex=>1, Encoding=>99, + * ThreadGroup=>1, Binding=>1, Thread=>1, RubyVM=>1, :iseq=>1, + * Random=>1, ARGF.class=>1, Data=>1, :autoload=>3, Time=>2} + * # T_DATA objects existing at startup on r32276. + * + * If the optional argument, result_hash, is given, it is overwritten and + * returned. This is intended to avoid probe effect. + * + * The contents of the returned hash is implementation specific and may change + * in the future. + * + * In this version, keys are Class object or Symbol object. + * + * If object is kind of normal (accessible) object, the key is Class object. + * If object is not a kind of normal (internal) object, the key is symbol + * name, registered by rb_data_type_struct. + * + * This method is only expected to work with C Ruby. + */ + +static VALUE +count_tdata_objects(int argc, VALUE *argv, VALUE self) +{ + VALUE hash; + + if (rb_scan_args(argc, argv, "01", &hash) == 1) { + if (!RB_TYPE_P(hash, T_HASH)) + rb_raise(rb_eTypeError, "non-hash given"); + } + + if (hash == Qnil) { + hash = rb_hash_new(); + } + else if (!RHASH_EMPTY_P(hash)) { + st_foreach(RHASH_TBL(hash), set_zero_i, hash); + } + + rb_objspace_each_objects(cto_i, (void *)hash); + + return hash; +} + +static void +iow_mark(void *ptr) +{ + rb_gc_mark((VALUE)ptr); +} + +static size_t +iow_size(const void *ptr) +{ + VALUE obj = (VALUE)ptr; + return rb_obj_memsize_of(obj); +} + +static const rb_data_type_t iow_data_type = { + "ObjectSpace::InternalObjectWrapper", + {iow_mark, 0, iow_size,}, + 0, 0, RUBY_TYPED_FREE_IMMEDIATELY +}; + +static VALUE rb_mInternalObjectWrapper; + +static VALUE +iow_newobj(VALUE obj) +{ + return rb_data_typed_object_alloc(rb_mInternalObjectWrapper, (void *)obj, &iow_data_type); +} + +/* Returns the type of the internal object. */ +static VALUE +iow_type(VALUE self) +{ + VALUE obj = (VALUE)DATA_PTR(self); + return type2sym(BUILTIN_TYPE(obj)); +} + +/* See Object#inspect. */ +static VALUE +iow_inspect(VALUE self) +{ + VALUE obj = (VALUE)DATA_PTR(self); + VALUE type = type2sym(BUILTIN_TYPE(obj)); + + return rb_sprintf("#<InternalObject:%p %"PRIsVALUE">", (void *)obj, rb_sym2str(type)); +} + +/* Returns the Object#object_id of the internal object. */ +static VALUE +iow_internal_object_id(VALUE self) +{ + VALUE obj = (VALUE)DATA_PTR(self); + return rb_obj_id(obj); +} + +struct rof_data { + st_table *refs; + VALUE internals; +}; + +static void +reachable_object_from_i(VALUE obj, void *data_ptr) +{ + struct rof_data *data = (struct rof_data *)data_ptr; + VALUE key = obj; + VALUE val = obj; + + if (rb_objspace_markable_object_p(obj)) { + if (rb_objspace_internal_object_p(obj)) { + val = iow_newobj(obj); + rb_ary_push(data->internals, val); + } + st_insert(data->refs, key, val); + } +} + +static int +collect_values(st_data_t key, st_data_t value, st_data_t data) +{ + VALUE ary = (VALUE)data; + rb_ary_push(ary, (VALUE)value); + return ST_CONTINUE; +} + +/* + * call-seq: + * ObjectSpace.reachable_objects_from(obj) -> array or nil + * + * [MRI specific feature] Return all reachable objects from `obj'. + * + * This method returns all reachable objects from `obj'. + * + * If `obj' has two or more references to the same object `x', then returned + * array only includes one `x' object. + * + * If `obj' is a non-markable (non-heap management) object such as true, + * false, nil, symbols and Fixnums (and Flonum) then it simply returns nil. + * + * If `obj' has references to an internal object, then it returns instances of + * ObjectSpace::InternalObjectWrapper class. This object contains a reference + * to an internal object and you can check the type of internal object with + * `type' method. + * + * If `obj' is instance of ObjectSpace::InternalObjectWrapper class, then this + * method returns all reachable object from an internal object, which is + * pointed by `obj'. + * + * With this method, you can find memory leaks. + * + * This method is only expected to work except with C Ruby. + * + * Example: + * ObjectSpace.reachable_objects_from(['a', 'b', 'c']) + * #=> [Array, 'a', 'b', 'c'] + * + * ObjectSpace.reachable_objects_from(['a', 'a', 'a']) + * #=> [Array, 'a', 'a', 'a'] # all 'a' strings have different object id + * + * ObjectSpace.reachable_objects_from([v = 'a', v, v]) + * #=> [Array, 'a'] + * + * ObjectSpace.reachable_objects_from(1) + * #=> nil # 1 is not markable (heap managed) object + * + */ + +static VALUE +reachable_objects_from(VALUE self, VALUE obj) +{ + if (rb_objspace_markable_object_p(obj)) { + VALUE ret = rb_ary_new(); + struct rof_data data; + + if (rb_typeddata_is_kind_of(obj, &iow_data_type)) { + obj = (VALUE)DATA_PTR(obj); + } + + data.refs = st_init_numtable(); + data.internals = rb_ary_new(); + + rb_objspace_reachable_objects_from(obj, reachable_object_from_i, &data); + + st_foreach(data.refs, collect_values, (st_data_t)ret); + return ret; + } + else { + return Qnil; + } +} + +struct rofr_data { + VALUE categories; + const char *last_category; + VALUE last_category_str; + VALUE last_category_objects; +}; + +static void +reachable_object_from_root_i(const char *category, VALUE obj, void *ptr) +{ + struct rofr_data *data = (struct rofr_data *)ptr; + VALUE category_str; + VALUE category_objects; + + if (category == data->last_category) { + category_str = data->last_category_str; + category_objects = data->last_category_objects; + } + else { + data->last_category = category; + category_str = data->last_category_str = rb_str_new2(category); + category_objects = data->last_category_objects = rb_hash_new(); + rb_funcall(category_objects, rb_intern("compare_by_identity"), 0); + if (!NIL_P(rb_hash_lookup(data->categories, category_str))) { + rb_bug("reachable_object_from_root_i: category should insert at once"); + } + rb_hash_aset(data->categories, category_str, category_objects); + } + + if (rb_objspace_markable_object_p(obj) && + obj != data->categories && + obj != data->last_category_objects) { + if (rb_objspace_internal_object_p(obj)) { + obj = iow_newobj(obj); + } + rb_hash_aset(category_objects, obj, obj); + } +} + +static int +collect_values_of_values(VALUE category, VALUE category_objects, VALUE categories) +{ + VALUE ary = rb_ary_new(); + st_foreach(rb_hash_tbl(category_objects), collect_values, ary); + rb_hash_aset(categories, category, ary); + return ST_CONTINUE; +} + +/* + * call-seq: + * ObjectSpace.reachable_objects_from_root -> hash + * + * [MRI specific feature] Return all reachable objects from root. + */ +static VALUE +reachable_objects_from_root(VALUE self) +{ + struct rofr_data data; + VALUE hash = data.categories = rb_hash_new(); + data.last_category = 0; + + rb_funcall(hash, rb_intern("compare_by_identity"), 0); + rb_objspace_reachable_objects_from_root(reachable_object_from_root_i, &data); + rb_hash_foreach(hash, collect_values_of_values, hash); + + return hash; +} + +void Init_object_tracing(VALUE rb_mObjSpace); +void Init_objspace_dump(VALUE rb_mObjSpace); + +/* + * Document-module: ObjectSpace + * + * The objspace library extends the ObjectSpace module and adds several + * methods to get internal statistic information about + * object/memory management. + * + * You need to <code>require 'objspace'</code> to use this extension module. + * + * Generally, you *SHOULD NOT* use this library if you do not know + * about the MRI implementation. Mainly, this library is for (memory) + * profiler developers and MRI developers who need to know about MRI + * memory usage. + */ + +void +Init_objspace(void) +{ + VALUE rb_mObjSpace; +#if 0 + rb_mObjSpace = rb_define_module("ObjectSpace"); /* let rdoc know */ +#endif + rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace")); + + rb_define_module_function(rb_mObjSpace, "memsize_of", memsize_of_m, 1); + rb_define_module_function(rb_mObjSpace, "memsize_of_all", memsize_of_all_m, -1); + + rb_define_module_function(rb_mObjSpace, "count_objects_size", count_objects_size, -1); + rb_define_module_function(rb_mObjSpace, "count_nodes", count_nodes, -1); + rb_define_module_function(rb_mObjSpace, "count_tdata_objects", count_tdata_objects, -1); + + rb_define_module_function(rb_mObjSpace, "reachable_objects_from", reachable_objects_from, 1); + rb_define_module_function(rb_mObjSpace, "reachable_objects_from_root", reachable_objects_from_root, 0); + + /* + * This class is used as a return value from + * ObjectSpace::reachable_objects_from. + * + * When ObjectSpace::reachable_objects_from returns an object with + * references to an internal object, an instance of this class is returned. + * + * You can use the #type method to check the type of the internal object. + */ + rb_mInternalObjectWrapper = rb_define_class_under(rb_mObjSpace, "InternalObjectWrapper", rb_cObject); + rb_define_method(rb_mInternalObjectWrapper, "type", iow_type, 0); + rb_define_method(rb_mInternalObjectWrapper, "inspect", iow_inspect, 0); + rb_define_method(rb_mInternalObjectWrapper, "internal_object_id", iow_internal_object_id, 0); + + Init_object_tracing(rb_mObjSpace); + Init_objspace_dump(rb_mObjSpace); +} diff --git a/jni/ruby/ext/objspace/objspace.h b/jni/ruby/ext/objspace/objspace.h new file mode 100644 index 0000000..95b84d6 --- /dev/null +++ b/jni/ruby/ext/objspace/objspace.h @@ -0,0 +1,20 @@ +#ifndef OBJSPACE_H +#define OBJSPACE_H 1 + +/* object_tracing.c */ +struct allocation_info { + /* all of information don't need marking. */ + int living; + VALUE flags; + VALUE klass; + + /* allocation info */ + const char *path; + unsigned long line; + const char *class_path; + VALUE mid; + size_t generation; +}; +struct allocation_info *objspace_lookup_allocation_info(VALUE obj); + +#endif diff --git a/jni/ruby/ext/objspace/objspace_dump.c b/jni/ruby/ext/objspace/objspace_dump.c new file mode 100644 index 0000000..b6973df --- /dev/null +++ b/jni/ruby/ext/objspace/objspace_dump.c @@ -0,0 +1,434 @@ +/********************************************************************** + + objspace_dump.c - Heap dumping ObjectSpace extender for MRI. + + $Author$ + created at: Sat Oct 11 10:11:00 2013 + + NOTE: This extension library is not expected to exist except C Ruby. + + All the files in this distribution are covered under the Ruby's + license (see the file COPYING). + +**********************************************************************/ + +#include "internal.h" +#include "ruby/debug.h" +#include "ruby/io.h" +#include "gc.h" +#include "node.h" +#include "vm_core.h" +#include "objspace.h" + +static VALUE sym_output, sym_stdout, sym_string, sym_file; + +struct dump_config { + VALUE type; + FILE *stream; + VALUE string; + int roots; + const char *root_category; + VALUE cur_obj; + VALUE cur_obj_klass; + size_t cur_obj_references; +}; + +static void +dump_append(struct dump_config *dc, const char *format, ...) +{ + va_list vl; + va_start(vl, format); + + if (dc->stream) { + vfprintf(dc->stream, format, vl); + } + else if (dc->string) + rb_str_vcatf(dc->string, format, vl); + + va_end(vl); +} + +static void +dump_append_string_value(struct dump_config *dc, VALUE obj) +{ + int i; + char c, *value; + + dump_append(dc, "\""); + for (i = 0, value = RSTRING_PTR(obj); i < RSTRING_LEN(obj); i++) { + switch ((c = value[i])) { + case '\\': + case '"': + dump_append(dc, "\\%c", c); + break; + case '\0': + dump_append(dc, "\\u0000"); + break; + case '\b': + dump_append(dc, "\\b"); + break; + case '\t': + dump_append(dc, "\\t"); + break; + case '\f': + dump_append(dc, "\\f"); + break; + case '\n': + dump_append(dc, "\\n"); + break; + case '\r': + dump_append(dc, "\\r"); + break; + default: + if (c <= 0x1f) + dump_append(dc, "\\u%04d", c); + else + dump_append(dc, "%c", c); + } + } + dump_append(dc, "\""); +} + +static inline const char * +obj_type(VALUE obj) +{ + switch (BUILTIN_TYPE(obj)) { +#define CASE_TYPE(type) case T_##type: return #type; break + CASE_TYPE(NONE); + CASE_TYPE(NIL); + CASE_TYPE(OBJECT); + CASE_TYPE(CLASS); + CASE_TYPE(ICLASS); + CASE_TYPE(MODULE); + CASE_TYPE(FLOAT); + CASE_TYPE(STRING); + CASE_TYPE(REGEXP); + CASE_TYPE(ARRAY); + CASE_TYPE(HASH); + CASE_TYPE(STRUCT); + CASE_TYPE(BIGNUM); + CASE_TYPE(FILE); + CASE_TYPE(FIXNUM); + CASE_TYPE(TRUE); + CASE_TYPE(FALSE); + CASE_TYPE(DATA); + CASE_TYPE(MATCH); + CASE_TYPE(SYMBOL); + CASE_TYPE(RATIONAL); + CASE_TYPE(COMPLEX); + CASE_TYPE(UNDEF); + CASE_TYPE(NODE); + CASE_TYPE(ZOMBIE); +#undef CASE_TYPE + } + return "UNKNOWN"; +} + +static void +reachable_object_i(VALUE ref, void *data) +{ + struct dump_config *dc = (struct dump_config *)data; + + if (dc->cur_obj_klass == ref) + return; + + if (dc->cur_obj_references == 0) + dump_append(dc, ", \"references\":[\"%p\"", (void *)ref); + else + dump_append(dc, ", \"%p\"", (void *)ref); + + dc->cur_obj_references++; +} + +static void +dump_object(VALUE obj, struct dump_config *dc) +{ + size_t memsize; + struct allocation_info *ainfo; + rb_io_t *fptr; + ID flags[RB_OBJ_GC_FLAGS_MAX]; + size_t n, i; + + if (SPECIAL_CONST_P(obj)) { + dump_append(dc, "{}"); + return; + } + + dc->cur_obj = obj; + dc->cur_obj_references = 0; + dc->cur_obj_klass = BUILTIN_TYPE(obj) == T_NODE ? 0 : RBASIC_CLASS(obj); + + if (dc->cur_obj == dc->string) + return; + + dump_append(dc, "{\"address\":\"%p\", \"type\":\"%s\"", (void *)obj, obj_type(obj)); + + if (dc->cur_obj_klass) + dump_append(dc, ", \"class\":\"%p\"", (void *)dc->cur_obj_klass); + if (rb_obj_frozen_p(obj)) + dump_append(dc, ", \"frozen\":true"); + + switch (BUILTIN_TYPE(obj)) { + case T_NODE: + dump_append(dc, ", \"node_type\":\"%s\"", ruby_node_name(nd_type(obj))); + break; + + case T_STRING: + if (STR_EMBED_P(obj)) + dump_append(dc, ", \"embedded\":true"); + if (is_broken_string(obj)) + dump_append(dc, ", \"broken\":true"); + if (FL_TEST(obj, RSTRING_FSTR)) + dump_append(dc, ", \"fstring\":true"); + if (STR_SHARED_P(obj)) + dump_append(dc, ", \"shared\":true"); + else { + dump_append(dc, ", \"bytesize\":%ld", RSTRING_LEN(obj)); + if (!STR_EMBED_P(obj) && !STR_SHARED_P(obj) && (long)rb_str_capacity(obj) != RSTRING_LEN(obj)) + dump_append(dc, ", \"capacity\":%ld", rb_str_capacity(obj)); + + if (is_ascii_string(obj)) { + dump_append(dc, ", \"value\":"); + dump_append_string_value(dc, obj); + } + } + + if (!ENCODING_IS_ASCII8BIT(obj)) + dump_append(dc, ", \"encoding\":\"%s\"", rb_enc_name(rb_enc_from_index(ENCODING_GET(obj)))); + break; + + case T_HASH: + dump_append(dc, ", \"size\":%ld", RHASH_SIZE(obj)); + if (FL_TEST(obj, HASH_PROC_DEFAULT)) + dump_append(dc, ", \"default\":\"%p\"", (void *)RHASH_IFNONE(obj)); + break; + + case T_ARRAY: + dump_append(dc, ", \"length\":%ld", RARRAY_LEN(obj)); + if (RARRAY_LEN(obj) > 0 && FL_TEST(obj, ELTS_SHARED)) + dump_append(dc, ", \"shared\":true"); + if (RARRAY_LEN(obj) > 0 && FL_TEST(obj, RARRAY_EMBED_FLAG)) + dump_append(dc, ", \"embedded\":true"); + break; + + case T_CLASS: + case T_MODULE: + if (dc->cur_obj_klass) + dump_append(dc, ", \"name\":\"%s\"", rb_class2name(obj)); + break; + + case T_DATA: + if (RTYPEDDATA_P(obj)) + dump_append(dc, ", \"struct\":\"%s\"", RTYPEDDATA_TYPE(obj)->wrap_struct_name); + break; + + case T_FLOAT: + dump_append(dc, ", \"value\":\"%g\"", RFLOAT_VALUE(obj)); + break; + + case T_OBJECT: + dump_append(dc, ", \"ivars\":%ld", ROBJECT_NUMIV(obj)); + break; + + case T_FILE: + fptr = RFILE(obj)->fptr; + if (fptr) + dump_append(dc, ", \"fd\":%d", fptr->fd); + break; + + case T_ZOMBIE: + dump_append(dc, "}\n"); + return; + } + + rb_objspace_reachable_objects_from(obj, reachable_object_i, dc); + if (dc->cur_obj_references > 0) + dump_append(dc, "]"); + + if ((ainfo = objspace_lookup_allocation_info(obj))) { + dump_append(dc, ", \"file\":\"%s\", \"line\":%lu", ainfo->path, ainfo->line); + if (RTEST(ainfo->mid)) { + VALUE m = rb_sym2str(ainfo->mid); + dump_append(dc, ", \"method\":\"%s\"", RSTRING_PTR(m)); + } + dump_append(dc, ", \"generation\":%"PRIuSIZE, ainfo->generation); + } + + if ((memsize = rb_obj_memsize_of(obj)) > 0) + dump_append(dc, ", \"memsize\":%"PRIuSIZE, memsize); + + if ((n = rb_obj_gc_flags(obj, flags, sizeof(flags))) > 0) { + dump_append(dc, ", \"flags\":{"); + for (i=0; i<n; i++) { + dump_append(dc, "\"%s\":true", rb_id2name(flags[i])); + if (i != n-1) dump_append(dc, ", "); + } + dump_append(dc, "}"); + } + + dump_append(dc, "}\n"); +} + +static int +heap_i(void *vstart, void *vend, size_t stride, void *data) +{ + VALUE v = (VALUE)vstart; + for (; v != (VALUE)vend; v += stride) { + if (RBASIC(v)->flags) + dump_object(v, data); + } + return 0; +} + +static void +root_obj_i(const char *category, VALUE obj, void *data) +{ + struct dump_config *dc = (struct dump_config *)data; + + if (dc->root_category != NULL && category != dc->root_category) + dump_append(dc, "]}\n"); + if (dc->root_category == NULL || category != dc->root_category) + dump_append(dc, "{\"type\":\"ROOT\", \"root\":\"%s\", \"references\":[\"%p\"", category, (void *)obj); + else + dump_append(dc, ", \"%p\"", (void *)obj); + + dc->root_category = category; + dc->roots++; +} + +static VALUE +dump_output(struct dump_config *dc, VALUE opts, VALUE output, const char *filename) +{ + VALUE tmp; + + if (RTEST(opts)) + output = rb_hash_aref(opts, sym_output); + + if (output == sym_stdout) { + dc->stream = stdout; + dc->string = Qnil; + } + else if (output == sym_file) { + rb_io_t *fptr; + rb_require("tempfile"); + tmp = rb_assoc_new(rb_str_new_cstr(filename), rb_str_new_cstr(".json")); + tmp = rb_funcallv(rb_path2class("Tempfile"), rb_intern("create"), 1, &tmp); + io: + dc->string = rb_io_get_write_io(tmp); + rb_io_flush(dc->string); + GetOpenFile(dc->string, fptr); + dc->stream = rb_io_stdio_file(fptr); + } + else if (output == sym_string) { + dc->string = rb_str_new_cstr(""); + } + else if (!NIL_P(tmp = rb_io_check_io(output))) { + output = sym_file; + goto io; + } + else { + rb_raise(rb_eArgError, "wrong output option: %"PRIsVALUE, output); + } + return output; +} + +static VALUE +dump_result(struct dump_config *dc, VALUE output) +{ + if (output == sym_string) { + return dc->string; + } + else if (output == sym_file) { + rb_io_flush(dc->string); + return dc->string; + } + else { + return Qnil; + } +} + +/* + * call-seq: + * ObjectSpace.dump(obj[, output: :string]) # => "{ ... }" + * ObjectSpace.dump(obj, output: :file) # => #<File:/tmp/rubyobj20131125-88733-1xkfmpv.json> + * ObjectSpace.dump(obj, output: :stdout) # => nil + * + * Dump the contents of a ruby object as JSON. + * + * This method is only expected to work with C Ruby. + * This is an experimental method and is subject to change. + * In particular, the function signature and output format are + * not guaranteed to be compatible in future versions of ruby. + */ + +static VALUE +objspace_dump(int argc, VALUE *argv, VALUE os) +{ + static const char filename[] = "rubyobj"; + VALUE obj = Qnil, opts = Qnil, output; + struct dump_config dc = {0,}; + + rb_scan_args(argc, argv, "1:", &obj, &opts); + + output = dump_output(&dc, opts, sym_string, filename); + + dump_object(obj, &dc); + + return dump_result(&dc, output); +} + +/* + * call-seq: + * ObjectSpace.dump_all([output: :file]) # => #<File:/tmp/rubyheap20131125-88469-laoj3v.json> + * ObjectSpace.dump_all(output: :stdout) # => nil + * ObjectSpace.dump_all(output: :string) # => "{...}\n{...}\n..." + * ObjectSpace.dump_all(output: + * File.open('heap.json','w')) # => #<File:heap.json> + * + * Dump the contents of the ruby heap as JSON. + * + * This method is only expected to work with C Ruby. + * This is an experimental method and is subject to change. + * In particular, the function signature and output format are + * not guaranteed to be compatible in future versions of ruby. + */ + +static VALUE +objspace_dump_all(int argc, VALUE *argv, VALUE os) +{ + static const char filename[] = "rubyheap"; + VALUE opts = Qnil, output; + struct dump_config dc = {0,}; + + rb_scan_args(argc, argv, "0:", &opts); + + output = dump_output(&dc, opts, sym_file, filename); + + /* dump roots */ + rb_objspace_reachable_objects_from_root(root_obj_i, &dc); + if (dc.roots) dump_append(&dc, "]}\n"); + + /* dump all objects */ + rb_objspace_each_objects(heap_i, &dc); + + return dump_result(&dc, output); +} + +void +Init_objspace_dump(VALUE rb_mObjSpace) +{ +#if 0 + rb_mObjSpace = rb_define_module("ObjectSpace"); /* let rdoc know */ +#endif + + rb_define_module_function(rb_mObjSpace, "dump", objspace_dump, -1); + rb_define_module_function(rb_mObjSpace, "dump_all", objspace_dump_all, -1); + + sym_output = ID2SYM(rb_intern("output")); + sym_stdout = ID2SYM(rb_intern("stdout")); + sym_string = ID2SYM(rb_intern("string")); + sym_file = ID2SYM(rb_intern("file")); + + /* force create static IDs */ + rb_obj_gc_flags(rb_mObjSpace, 0, 0); +} |