darshan-ruby 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1e3b14bb796900d053874e17ed26540b32855f0
+  data.tar.gz: 075a3a3789edf6237427d869403ab45f228b4a0f
+SHA512:
+  metadata.gz: bbe57d68844f84f2f69837727decab1b98884137f3d907b713c50500c6deebfe44a3c2e4f643b17edc534d5a6f8bc4eb483292e0b8b1d186fcebe87f9bfe2afd
+  data.tar.gz: 6396e0d9ed8d20487a8d148ffdd33ea4a8fc5b0c2d8482b2b1f92536f98342e8c56c4faaf5dedec27e283fa0dd4d5360ac8a818c0ca96907ea6487916b9d3c3e

data/ext/darshan/bgq-module.c

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include "darshan-ruby.h"
+
+extern VALUE cDarshanRecord;
+extern VALUE mDarshan;
+
+VALUE cDarshanBGQRecord;
+VALUE mDarshanBGQ;
+
+static VALUE Darshan3rb_bgq_get_rank(VALUE self)
+{
+	struct darshan_bgq_record* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	if(c_record) return LL2NUM(c_record->rank);
+	else return Qnil;
+}
+
+static VALUE Darshan3rb_bgq_get_alignment(VALUE self)
+{
+	struct darshan_bgq_record* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	if(c_record) return INT2NUM(c_record->alignment);
+	else return Qnil;
+}
+
+static VALUE Darshan3rb_bgq_get_counter(VALUE self, VALUE index)
+{
+	struct darshan_bgq_record* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	int i = NUM2INT(index);
+	if((i < 0) || (c_record == NULL)) return Qnil;
+	if(i < BGQ_NUM_INDICES) return LL2NUM(c_record->counters[i]);
+	if(i < BGQ_NUM_INDICES+BGQ_F_NUM_INDICES) return rb_float_new(c_record->fcounters[i-BGQ_NUM_INDICES]);
+	else return Qnil;
+}
+
+void Darshan3rb_init_bgq()
+{
+	mDarshanBGQ = rb_define_module_under(mDarshan,"BGQ");
+
+	VALUE cnames = rb_ary_new2(BGQ_NUM_INDICES+BGQ_F_NUM_INDICES);
+	int i;
+	for(i=0; i < BGQ_NUM_INDICES; i++) {
+		rb_ary_store(cnames,i,rb_str_new2(bgq_counter_names[i]));
+		rb_define_const(mDarshanBGQ,bgq_counter_names[i],INT2NUM(i));
+	}
+	for(i=0; i < BGQ_F_NUM_INDICES; i++) {
+		int j = i+BGQ_NUM_INDICES;
+		rb_ary_store(cnames,j,rb_str_new2(bgq_f_counter_names[i]));
+		rb_define_const(mDarshanBGQ,bgq_f_counter_names[i],INT2NUM(j));
+	}
+	rb_define_const(mDarshanBGQ,"NAMES",cnames);
+
+	cDarshanBGQRecord = rb_define_class_under(mDarshanBGQ,"Record",cDarshanRecord);
+	rb_define_method(cDarshanBGQRecord,"rank",Darshan3rb_bgq_get_rank,0);
+	rb_define_method(cDarshanBGQRecord,"counter",Darshan3rb_bgq_get_counter,1);
+	rb_define_method(cDarshanBGQRecord,"alignment",Darshan3rb_bgq_get_alignment,0);
+}
+
+VALUE Darshan3rb_get_bgq_record(darshan_fd fd, darshan_record_id* rec_id)
+{
+	struct darshan_bgq_record* c_record = (struct darshan_bgq_record*)malloc(sizeof(struct darshan_bgq_record));	
+	int r = mod_logutils[DARSHAN_BGQ_MOD]->log_get_record(fd, (char*)c_record, rec_id);
+	if(r != 1) return Qnil;
+
+	VALUE rb_record = Data_Wrap_Struct(cDarshanBGQRecord, NULL , free, c_record);
+	return rb_record;
+}

data/ext/darshan/bgq-module.h

@@ -0,0 +1,11 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include <ruby.h>
+
+void Darshan3rb_init_bgq();
+
+VALUE Darshan3rb_get_bgq_record(darshan_fd fd, darshan_record_id* rec_id);

data/ext/darshan/darshan-ruby.c

@@ -0,0 +1,253 @@
+/*
+ *  (C) 2009 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+#include "darshan-ruby.h"
+
+VALUE mDarshan; 	// Darshan module in Ruby
+VALUE cDarshanException;// Darshan::Exception class
+VALUE cDarshanLogFile; 	// Darshan::LogFile class
+VALUE cDarshanRecord;	// Darshan::Record class
+VALUE cDarshanModule;	// Darshan::Module class
+VALUE cDarshanHash;	// Darshan::Hash class
+
+/* Within: Darshan module
+ * Opens a log file using its name.
+ * Returns an instance of Darshan::LogFile on sucess, nil on failure.
+ */
+static VALUE rb_darshan_open(VALUE self, VALUE name)
+{
+	const char* c_name = rb_string_value_cstr(&name);
+	darshan_fd fd = darshan_log_open(c_name);
+	char buffer[DARSHAN_JOB_METADATA_LEN];
+	if(fd != NULL) {
+		VALUE res = Data_Wrap_Struct(cDarshanLogFile, NULL ,NULL, fd);
+		// set the name of the file
+		rb_iv_set(res, "@name", name);//rb_str_new2(fd->name));
+
+		// get the job struct
+		struct darshan_job job;
+		int err = darshan_log_getjob(fd,&job);
+
+		if(err < 0) return Qnil;
+		
+		// set the version number
+		rb_iv_set(res,"@version", rb_str_new2(fd->version));
+		// set the uid
+		rb_iv_set(res,"@uid", LL2NUM(job.uid));
+		// set the start time
+		rb_iv_set(res,"@start_time", LL2NUM(job.start_time));
+		// set the end time
+		rb_iv_set(res,"@end_time", LL2NUM(job.end_time));
+		// set the job id
+		rb_iv_set(res,"@job_id", LL2NUM(job.jobid));
+		// set the number of processes
+		rb_iv_set(res,"@nprocs", LL2NUM(job.nprocs));
+		// set the metadata
+		VALUE metadata = rb_hash_new();
+		char *token;
+		char *save;
+		for(token=strtok_r(job.metadata, "\n", &save);
+		    token != NULL;
+		    token=strtok_r(NULL, "\n", &save)) {
+			char *key;
+			char *value;
+			strcpy(buffer, token);
+			key = buffer;
+			value = index(buffer, '=');
+			if(!value) continue;
+			value[0] = '\0';
+			value++;
+			rb_hash_aset(metadata, rb_str_new2(key), rb_str_new2(value));
+		}
+		rb_iv_set(res,"@metadata", metadata);
+
+		// set the executable name
+		char exe[DARSHAN_EXE_LEN+2];
+		err = darshan_log_getexe(fd, exe);
+
+		if(err < 0) return Qnil;
+
+                rb_iv_set(res,"@exe", rb_str_new2(exe));
+
+		rb_iv_set(res,"@partial", fd->partial_flag ? Qtrue : Qfalse);
+
+		rb_iv_set(res,"@current_module", INT2NUM(-1));
+
+		// set the list of mount points
+		char** mnt_pts = NULL;
+		char** fs_types = NULL;
+		int count = 0;
+		err = darshan_log_getmounts(fd,&mnt_pts,&fs_types,&count);
+		
+		if(err < 0) {
+			return Qnil;
+		}
+
+		VALUE path = ID2SYM(rb_intern("path"));
+		VALUE type = ID2SYM(rb_intern("type"));
+		VALUE mp = rb_ary_new2(count);
+		int i;
+		for(i=0; i<count; i++) {
+			VALUE hash = rb_hash_new();
+			rb_hash_aset(hash,path,rb_str_new2(mnt_pts[i]));
+			rb_hash_aset(hash,type,rb_str_new2(fs_types[i]));
+			rb_ary_store(mp,i,hash);
+			if(mnt_pts != NULL && mnt_pts[i] != NULL) 
+				free(mnt_pts[i]);
+			if(fs_types != NULL && fs_types[i] != NULL)
+				free(fs_types[i]);
+		}
+
+		if(mnt_pts != NULL) free(mnt_pts);
+		if(fs_types != NULL) free(fs_types);
+		rb_iv_set(res,"@mount_points", mp);
+
+		// get the hash
+		struct darshan_record_ref *rec_hash = NULL;
+		err = darshan_log_gethash(fd, &rec_hash);
+		if(err < 0) {
+			return Qnil;
+		}
+
+		VALUE rb_hash = Data_Wrap_Struct(cDarshanHash, NULL ,NULL, rec_hash);
+		rb_iv_set(res,"@hash",rb_hash);
+
+		return res;
+	} else {
+		return Qnil;
+	}
+}
+
+/* Within: Darshan module
+ * Closes a file (instance of Darshan::LogFile)
+ * Returns true on success, false on failure.
+ */
+static VALUE rb_darshan_close(VALUE self, VALUE fd)
+{
+	darshan_fd c_fd = NULL;
+	Data_Get_Struct(fd,struct darshan_fd_s,c_fd);
+	if(c_fd != NULL) {
+		darshan_log_close(c_fd);
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+/* Within: Darshan::Module LogFile class
+ * Returns the next Darshan::Module entry from the log file,
+ * or nil if there is no more modules to read.
+ */
+static VALUE rb_darshan_next_module(VALUE self) 
+{
+	darshan_fd fd = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s, fd);
+	if(fd == NULL) return Qnil;
+	int i = NUM2INT(rb_iv_get(self,"@current_module"));
+	i +=1;
+
+	while(fd->mod_map[i].len == 0 && i < DARSHAN_MAX_MODS) i++;
+	if(i >= DARSHAN_MAX_MODS || (!mod_logutils[i])) {
+		rb_iv_set(self,"@current_module",INT2NUM(i));
+		return Qnil;
+	}
+	// Creat a Darshan::Module object
+	VALUE argv[0];
+	VALUE res = rb_class_new_instance(0, argv, cDarshanModule);
+	VALUE name = rb_str_new2(darshan_module_names[i]);
+	VALUE length = LL2NUM(fd->mod_map[i].len);
+
+	rb_iv_set(res,"@name", name);
+	rb_iv_set(res,"@length", length);
+
+	rb_iv_set(res,"@fd",self);
+	rb_iv_set(res,"@index",	INT2NUM(i));
+
+	rb_iv_set(self,"@current_module",INT2NUM(i));
+
+	return res;
+}
+
+/* Within: Darshan::Module class
+ * Returns the next Darshan::Record entry from the module,
+ * or nil if there is no more such an entry.
+ */
+static VALUE rb_darshan_next_record(VALUE self)
+{
+	// get the index of the module to access its functions
+	int i = NUM2INT(rb_iv_get(self,"@index"));
+
+	// get the parent log file descriptor
+	VALUE rfd = rb_iv_get(self,"@fd");
+	darshan_fd fd = NULL;
+	Data_Get_Struct(rfd,struct darshan_fd_s, fd);
+	if(fd == NULL) return Qnil;
+
+	VALUE rbhash = rb_iv_get(rfd,"@hash");
+	struct darshan_record_ref* rec_hash = NULL;
+	Data_Get_Struct(rbhash,struct darshan_record_ref, rec_hash);
+	if(rec_hash == NULL) return Qnil;
+
+	darshan_record_id rec_id;
+
+	VALUE res = Qnil;
+	switch(i) {
+	case DARSHAN_NULL_MOD:
+		res = Qnil;
+		break;
+	case DARSHAN_POSIX_MOD:
+		res = Darshan3rb_get_posix_record(fd,&rec_id);
+		break;
+	case DARSHAN_MPIIO_MOD:
+		res = Darshan3rb_get_mpiio_record(fd,&rec_id);
+		break;
+	case DARSHAN_HDF5_MOD:
+		res = Darshan3rb_get_hdf5_record(fd,&rec_id);
+		break;
+	case DARSHAN_PNETCDF_MOD:
+		res = Darshan3rb_get_pnetcdf_record(fd,&rec_id);
+		break;
+	case DARSHAN_BGQ_MOD:
+		res = Darshan3rb_get_bgq_record(fd,&rec_id);
+		break;
+	}
+
+	if(res == Qnil) return Qnil;
+
+	struct darshan_record_ref* ref;
+	HASH_FIND(hlink, rec_hash, &rec_id, sizeof(darshan_record_id), ref);
+
+	rb_iv_set(res,"@name",rb_str_new2(ref->rec.name));
+
+	return res;
+}
+
+/* Initialize the Darshan Ruby library
+ */
+void Init_Darshan3rb() {
+  	mDarshan = rb_define_module("Darshan");
+
+	cDarshanLogFile 	= rb_define_class_under(mDarshan,"LogFile",	rb_cObject);
+	cDarshanException 	= rb_define_class_under(mDarshan,"Exception",	rb_cObject);
+	cDarshanModule 		= rb_define_class_under(mDarshan,"Module",	rb_cObject);
+	cDarshanRecord		= rb_define_class_under(mDarshan,"Record",	rb_cObject);
+	cDarshanHash		= rb_define_class_under(mDarshan,"Hash",	rb_cObject);
+
+	rb_define_module_function(mDarshan,"open",	rb_darshan_open,	1);
+	rb_define_module_function(mDarshan,"close",	rb_darshan_close,	1);
+
+	rb_define_const(mDarshan,"VERSION",rb_str_new2(DARSHAN_LOG_VERSION));
+
+	Darshan3rb_init_posix();
+	Darshan3rb_init_mpiio();
+	Darshan3rb_init_hdf5();
+	Darshan3rb_init_pnetcdf();
+	Darshan3rb_init_bgq();
+
+	rb_define_method(cDarshanLogFile,"next_module",
+			rb_darshan_next_module,0);
+	rb_define_method(cDarshanModule,"next_record",
+			rb_darshan_next_record,0);
+}
+

data/ext/darshan/darshan-ruby.h

@@ -0,0 +1,19 @@
+/*
+ *  (C) 2009 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+#ifndef DARSHAN_RUBY_H
+#define DARSHAN_RUBY_H
+
+#include <ruby.h>
+#define DARSHAN_CONFIG_H "darshan-util-config.h"
+#include <darshan-logutils.h> 
+
+#include "posix-module.h"
+#include "mpiio-module.h"
+#include "hdf5-module.h"
+#include "pnetcdf-module.h"
+#include "bgq-module.h"
+
+#endif

data/ext/darshan/extconf.rb

@@ -0,0 +1,34 @@
+#
+#  (C) 2015 by Argonne National Laboratory.
+#      See COPYRIGHT in top-level directory.
+#
+
+require 'mkmf'
+
+dir_config('darshan')
+dir_config('z')
+dir_config('bz2')
+
+if(not have_header('darshan-log-format.h'))
+	$stderr << "Error, could not find darshan-log-format.h\n"
+	$stderr << "Please use --with-darshan-dir=...\n"
+	abort "Missing darshan-log-format.h"
+end
+
+if(not have_library('z'))
+	$stderr << "Error, could not locate zlib.\n"
+	abort "Missing zlib"
+end
+
+if(not have_library('bz2'))
+	$stderr << "Error, could not locate libbz2.\n"
+	abort "Missing bz2"
+end
+
+if(not have_library('darshan-util'))
+	$stderr << "Error, could not locate libdarshan-util.a\n"
+	$stderr << "Please use --with-darshan-dir=...\n"
+	abort "Missing libdarshan-util.a"
+end
+
+create_makefile("Darshan3rb")

data/ext/darshan/hdf5-module.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include "darshan-ruby.h"
+
+extern VALUE cDarshanRecord;
+extern VALUE mDarshan;
+
+VALUE cDarshanHDF5Record;
+VALUE mDarshanHDF5;
+
+static VALUE Darshan3rb_hdf5_get_rank(VALUE self)
+{
+	struct darshan_hdf5_file* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	if(c_record) return LL2NUM(c_record->rank);
+	else return Qnil;
+}
+
+static VALUE Darshan3rb_hdf5_get_counter(VALUE self, VALUE index)
+{
+	struct darshan_hdf5_file* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	int i = NUM2INT(index);
+	if((i < 0) || (c_record == NULL)) return Qnil;
+	if(i < HDF5_NUM_INDICES) return LL2NUM(c_record->counters[i]);
+	if(i < HDF5_NUM_INDICES+HDF5_F_NUM_INDICES) return rb_float_new(c_record->fcounters[i-HDF5_NUM_INDICES]);
+	else return Qnil;
+}
+
+void Darshan3rb_init_hdf5()
+{
+	mDarshanHDF5 = rb_define_module_under(mDarshan,"HDF5");
+
+	VALUE cnames = rb_ary_new2(HDF5_NUM_INDICES+HDF5_F_NUM_INDICES);
+	int i;
+	for(i=0; i < HDF5_NUM_INDICES; i++) {
+		rb_ary_store(cnames,i,rb_str_new2(hdf5_counter_names[i]));
+		rb_define_const(mDarshanHDF5,hdf5_counter_names[i],INT2NUM(i));
+	}
+	for(i=0; i < HDF5_F_NUM_INDICES; i++) {
+		int j = i+HDF5_NUM_INDICES;
+		rb_ary_store(cnames,j,rb_str_new2(hdf5_f_counter_names[i]));
+		rb_define_const(mDarshanHDF5,hdf5_f_counter_names[i],INT2NUM(j));
+	}
+	rb_define_const(mDarshanHDF5,"NAMES",cnames);
+
+	cDarshanHDF5Record = rb_define_class_under(mDarshanHDF5,"Record",cDarshanRecord);
+	rb_define_method(cDarshanHDF5Record,"rank",Darshan3rb_hdf5_get_rank,0);
+	rb_define_method(cDarshanHDF5Record,"counter",Darshan3rb_hdf5_get_counter,1);
+}
+
+VALUE Darshan3rb_get_hdf5_record(darshan_fd fd, darshan_record_id* rec_id)
+{
+	struct darshan_hdf5_file* c_record = (struct darshan_hdf5_file*)malloc(sizeof(struct darshan_hdf5_file));	
+	int r = mod_logutils[DARSHAN_HDF5_MOD]->log_get_record(fd, (char*)c_record, rec_id);
+	if(r != 1) return Qnil;
+
+	VALUE rb_record = Data_Wrap_Struct(cDarshanHDF5Record, NULL , free, c_record);
+	return rb_record;
+}

data/ext/darshan/hdf5-module.h

@@ -0,0 +1,11 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include <ruby.h>
+
+void Darshan3rb_init_hdf5();
+
+VALUE Darshan3rb_get_hdf5_record(darshan_fd fd, darshan_record_id* rec_id);

data/ext/darshan/mpiio-module.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include "darshan-ruby.h"
+
+extern VALUE cDarshanRecord;
+extern VALUE mDarshan;
+
+VALUE cDarshanMPIIORecord;
+VALUE mDarshanMPIIO;
+
+static VALUE Darshan3rb_mpiio_get_rank(VALUE self)
+{
+	struct darshan_mpiio_file* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	if(c_record) return LL2NUM(c_record->rank);
+	else return Qnil;
+}
+
+static VALUE Darshan3rb_mpiio_get_counter(VALUE self, VALUE index)
+{
+	struct darshan_mpiio_file* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	int i = NUM2INT(index);
+	if((i < 0) || (c_record == NULL)) return Qnil;
+	if(i < MPIIO_NUM_INDICES) return LL2NUM(c_record->counters[i]);
+	if(i < MPIIO_NUM_INDICES+MPIIO_F_NUM_INDICES) return rb_float_new(c_record->fcounters[i-MPIIO_NUM_INDICES]);
+	else return Qnil;
+}
+
+void Darshan3rb_init_mpiio()
+{
+	mDarshanMPIIO = rb_define_module_under(mDarshan,"MPIIO");
+
+	VALUE cnames = rb_ary_new2(MPIIO_NUM_INDICES+MPIIO_F_NUM_INDICES);
+	int i;
+	for(i=0; i < MPIIO_NUM_INDICES; i++) {
+		rb_ary_store(cnames,i,rb_str_new2(mpiio_counter_names[i]));
+		rb_define_const(mDarshanMPIIO,mpiio_counter_names[i],INT2NUM(i));
+	}
+	for(i=0; i < MPIIO_F_NUM_INDICES; i++) {
+		int j = i+MPIIO_NUM_INDICES;
+		rb_ary_store(cnames,j,rb_str_new2(mpiio_f_counter_names[i]));
+		rb_define_const(mDarshanMPIIO,mpiio_f_counter_names[i],INT2NUM(j));
+	}
+	rb_define_const(mDarshanMPIIO,"NAMES",cnames);
+
+	cDarshanMPIIORecord = rb_define_class_under(mDarshanMPIIO,"Record",cDarshanRecord);
+	rb_define_method(cDarshanMPIIORecord,"rank",Darshan3rb_mpiio_get_rank,0);
+	rb_define_method(cDarshanMPIIORecord,"counter",Darshan3rb_mpiio_get_counter,1);
+}
+
+VALUE Darshan3rb_get_mpiio_record(darshan_fd fd, darshan_record_id* rec_id)
+{
+	struct darshan_mpiio_file* c_record = (struct darshan_mpiio_file*)malloc(sizeof(struct darshan_mpiio_file));	
+	int r = mod_logutils[DARSHAN_MPIIO_MOD]->log_get_record(fd, (char*)c_record, rec_id);
+	if(r != 1) return Qnil;
+
+	VALUE rb_record = Data_Wrap_Struct(cDarshanMPIIORecord, NULL , free, c_record);
+	return rb_record;
+}

data/ext/darshan/mpiio-module.h

@@ -0,0 +1,11 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include <ruby.h>
+
+void Darshan3rb_init_mpiio();
+
+VALUE Darshan3rb_get_mpiio_record(darshan_fd fd, darshan_record_id* rec_id);

data/ext/darshan/pnetcdf-module.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include "darshan-ruby.h"
+
+extern VALUE cDarshanRecord;
+extern VALUE mDarshan;
+
+VALUE cDarshanPNETCDFRecord;
+VALUE mDarshanPNETCDF;
+
+static VALUE Darshan3rb_pnetcdf_get_rank(VALUE self)
+{
+	struct darshan_pnetcdf_file* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	if(c_record) return LL2NUM(c_record->rank);
+	else return Qnil;
+}
+
+static VALUE Darshan3rb_pnetcdf_get_counter(VALUE self, VALUE index)
+{
+	struct darshan_pnetcdf_file* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	int i = NUM2INT(index);
+	if((i < 0) || (c_record == NULL)) return Qnil;
+	if(i < PNETCDF_NUM_INDICES) return LL2NUM(c_record->counters[i]);
+	if(i < PNETCDF_NUM_INDICES+PNETCDF_F_NUM_INDICES) return rb_float_new(c_record->fcounters[i-PNETCDF_NUM_INDICES]);
+	else return Qnil;
+}
+
+void Darshan3rb_init_pnetcdf()
+{
+	mDarshanPNETCDF = rb_define_module_under(mDarshan,"PNETCDF");
+
+	VALUE cnames = rb_ary_new2(PNETCDF_NUM_INDICES+PNETCDF_F_NUM_INDICES);
+	int i;
+	for(i=0; i < PNETCDF_NUM_INDICES; i++) {
+		rb_ary_store(cnames,i,rb_str_new2(pnetcdf_counter_names[i]));
+		rb_define_const(mDarshanPNETCDF,pnetcdf_counter_names[i],INT2NUM(i));
+	}
+	for(i=0; i < PNETCDF_F_NUM_INDICES; i++) {
+		int j = i+PNETCDF_NUM_INDICES;
+		rb_ary_store(cnames,j,rb_str_new2(pnetcdf_f_counter_names[i]));
+		rb_define_const(mDarshanPNETCDF,pnetcdf_f_counter_names[i],INT2NUM(j));
+	}
+	rb_define_const(mDarshanPNETCDF,"NAMES",cnames);
+
+	cDarshanPNETCDFRecord = rb_define_class_under(mDarshanPNETCDF,"Record",cDarshanRecord);
+	rb_define_method(cDarshanPNETCDFRecord,"rank",Darshan3rb_pnetcdf_get_rank,0);
+	rb_define_method(cDarshanPNETCDFRecord,"counter",Darshan3rb_pnetcdf_get_counter,1);
+}
+
+VALUE Darshan3rb_get_pnetcdf_record(darshan_fd fd, darshan_record_id* rec_id)
+{
+	struct darshan_pnetcdf_file* c_record = (struct darshan_pnetcdf_file*)malloc(sizeof(struct darshan_pnetcdf_file));	
+	int r = mod_logutils[DARSHAN_PNETCDF_MOD]->log_get_record(fd, (char*)c_record, rec_id);
+	if(r != 1) return Qnil;
+
+	VALUE rb_record = Data_Wrap_Struct(cDarshanPNETCDFRecord, NULL , free, c_record);
+	return rb_record;
+}

data/ext/darshan/pnetcdf-module.h

@@ -0,0 +1,11 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include <ruby.h>
+
+void Darshan3rb_init_pnetcdf();
+
+VALUE Darshan3rb_get_pnetcdf_record(darshan_fd fd, darshan_record_id* rec_id);

data/ext/darshan/posix-module.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include "darshan-ruby.h"
+
+extern VALUE cDarshanRecord;
+extern VALUE mDarshan;
+
+VALUE cDarshanPOSIXRecord;
+VALUE mDarshanPOSIX;
+
+static VALUE Darshan3rb_posix_get_rank(VALUE self)
+{
+	struct darshan_posix_file* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	if(c_record) return LL2NUM(c_record->rank);
+	else return Qnil;
+}
+
+static VALUE Darshan3rb_posix_get_counter(VALUE self, VALUE index)
+{
+	struct darshan_posix_file* c_record = NULL;
+	Data_Get_Struct(self,struct darshan_fd_s,c_record);
+	int i = NUM2INT(index);
+	if((i < 0) || (c_record == NULL)) return Qnil;
+	if(i < POSIX_NUM_INDICES) return LL2NUM(c_record->counters[i]);
+	if(i < POSIX_NUM_INDICES+POSIX_F_NUM_INDICES) return rb_float_new(c_record->fcounters[i-POSIX_NUM_INDICES]);
+	else return Qnil;
+}
+
+void Darshan3rb_init_posix()
+{
+	mDarshanPOSIX = rb_define_module_under(mDarshan,"POSIX");
+
+	VALUE cnames = rb_ary_new2(POSIX_NUM_INDICES+POSIX_F_NUM_INDICES);
+	int i;
+	for(i=0; i < POSIX_NUM_INDICES; i++) {
+		rb_ary_store(cnames,i,rb_str_new2(posix_counter_names[i]));
+		rb_define_const(mDarshanPOSIX,posix_counter_names[i],INT2NUM(i));
+	}
+	for(i=0; i < POSIX_F_NUM_INDICES; i++) {
+		int j = i+POSIX_NUM_INDICES;
+		rb_ary_store(cnames,j,rb_str_new2(posix_f_counter_names[i]));
+		rb_define_const(mDarshanPOSIX,posix_f_counter_names[i],INT2NUM(j));
+	}
+	rb_define_const(mDarshanPOSIX,"NAMES",cnames);
+
+	cDarshanPOSIXRecord = rb_define_class_under(mDarshanPOSIX,"Record",cDarshanRecord);
+	rb_define_method(cDarshanPOSIXRecord,"rank",Darshan3rb_posix_get_rank,0);
+	rb_define_method(cDarshanPOSIXRecord,"counter",Darshan3rb_posix_get_counter,1);
+}
+
+VALUE Darshan3rb_get_posix_record(darshan_fd fd, darshan_record_id* rec_id)
+{
+	struct darshan_posix_file* c_record = (struct darshan_posix_file*)malloc(sizeof(struct darshan_posix_file));	
+	int r = mod_logutils[DARSHAN_POSIX_MOD]->log_get_record(fd, (char*)c_record, rec_id);
+	if(r != 1) return Qnil;
+
+	VALUE rb_record = Data_Wrap_Struct(cDarshanPOSIXRecord, NULL , free, c_record);
+	return rb_record;
+}

data/ext/darshan/posix-module.h

@@ -0,0 +1,11 @@
+/*
+ * Copyright (C) 2015 University of Chicago.
+ * See COPYRIGHT notice in top-level directory.
+ *
+ */
+
+#include <ruby.h>
+
+void Darshan3rb_init_posix();
+
+VALUE Darshan3rb_get_posix_record(darshan_fd fd, darshan_record_id* rec_id);

data/lib/darshan.rb

@@ -0,0 +1,120 @@
+#######################################################################
+# Author: 	Matthieu Dorier
+# Institution: 	Argonne National Laboratory
+# Mail: 	mdorier [at] anl.gov
+# Date: 	October 2015
+#######################################################################
+require "Darshan3rb"
+
+#=====================================================================#
+# Darshan module, contains the functions to open and close a LogFile,
+# as well as all the classes (LogFile, Job and File). Some of these
+# classes are defined through the C code, and are thus not shown here.
+#=====================================================================#
+module Darshan
+
+	#=============================================================#
+	# LogFile class, represents a binary log file (compressed).
+	# Open it by using
+	#	logfile = LogFile.open("filename")
+	#	...
+	#	logfile.close
+	# or
+	#	LogFile.open("filename") do | logfile |
+	#		...
+	#	end
+	#=============================================================#
+	class LogFile
+
+		attr_reader :name
+		attr_reader :version
+		attr_reader :exe
+		attr_reader :uid
+		attr_reader :job_id
+		attr_reader :nprocs
+		attr_reader :metadata
+		attr_reader :mount_points
+
+		#=====================================================#
+		# Opens a logfile, calls the given block if present.
+		# The file is open for reading only.
+		#=====================================================#
+		def self.open(filename)
+			lf = Darshan.open(filename)
+			if block_given? and lf != nil
+				yield lf
+				lf.close
+				lf = nil
+			end
+			return lf
+		end
+
+		#=====================================================#
+		# Creates a logfile, calls the given block if present.
+		# The file is open for writing.
+		#=====================================================#
+		def self.create(filename)
+			lf = Darshan.create(filename)
+			if block_given? and lf != nil
+				yield lf
+				lf.close
+				lf = nil
+			end
+			return lf
+		end
+
+		#======================================================#
+		# Close the file.
+		#======================================================#
+		def close
+			Darshan.close(self)
+		end
+
+		#======================================================#
+		# Iterates through all the file entries described in
+		# the log file.
+		#======================================================#
+		def each_module
+			if not block_given?
+				return nil
+			end
+			mod = nil
+			while((mod = next_module()) != nil)
+				yield mod
+			end
+			return nil
+		end
+
+		def partial?
+			@partial
+		end
+
+		def start_time
+			Time.at(@start_time)
+		end
+
+		def end_time
+			Time.at(@end_time)
+		end
+	end
+
+	class Module
+		
+		attr_reader :name
+		attr_reader :length
+		attr_reader :index
+
+		def each_record
+			return nil if not block_given?
+			rec = nil
+			while((rec = next_record()) != nil)
+				yield rec
+			end
+			return nil
+		end
+	end
+
+	class Record
+		attr_reader :name
+	end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: darshan-ruby
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Matthieu Dorier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-31 00:00:00.000000000 Z
+dependencies: []
+description: Ruby binding to ANL's Darshan library for HPC I/O tracing and analysis
+email: mdorier@anl.gov
+executables: []
+extensions:
+- ext/darshan/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/darshan/bgq-module.c
+- ext/darshan/bgq-module.h
+- ext/darshan/darshan-ruby.c
+- ext/darshan/darshan-ruby.h
+- ext/darshan/extconf.rb
+- ext/darshan/hdf5-module.c
+- ext/darshan/hdf5-module.h
+- ext/darshan/mpiio-module.c
+- ext/darshan/mpiio-module.h
+- ext/darshan/pnetcdf-module.c
+- ext/darshan/pnetcdf-module.h
+- ext/darshan/posix-module.c
+- ext/darshan/posix-module.h
+- lib/darshan.rb
+homepage: http://www.mcs.anl.gov/research/projects/darshan/
+licenses:
+- GOVERNMENT LICENSE
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: nowarning
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby binding to Darshan version 3 and above
+test_files: []