Merge pull request #253 from ComputationalRadiationPhysics/dev

Release 1.5.0: Write Emtpy Group Attributes & File Name API

Author: psychocoderHPC

.travis.yml

@@ -20,17 +20,17 @@ env:
 script:
   - cd $BUILD
 # compile libSplash and install
-  - cmake -DTOOLS_MPI=$SPLASHMPI $SRC
+  - CXXFLAGS="-Werror" cmake -DCMAKE_BUILD_TYPE=Debug -DTOOLS_MPI=$SPLASHMPI $SRC
   - make package
   - sudo dpkg -i libsplash*.deb
   - ls -hal /usr/share/pyshared/
   - rm -rf $BUILD/*
 # compile examples/
-  - cmake -DWITH_MPI=$SPLASHMPI $SRC/examples
+  - CXXFLAGS="-Werror" cmake -DCMAKE_BUILD_TYPE=Debug -DWITH_MPI=$SPLASHMPI $SRC/examples
   - make
   - rm -rf $BUILD/*
 # compile and run tests/
-  - cmake -DWITH_MPI=$SPLASHMPI $SRC/tests
+  - CXXFLAGS="-Werror" cmake -DCMAKE_BUILD_TYPE=Debug -DWITH_MPI=$SPLASHMPI $SRC/tests
   - make
 # run tests
   - $SRC/tests/run_tests $BUILD

CHANGELOG.md

@@ -1,6 +1,30 @@
 Change Log for libSplash
 ================================================================
 
+Release 1.5.0
+-------------
+**Date:** 2016-10-26
+
+Written attributes do now generate their according group path
+recursively if it does not exist and the `SerialDataCollector`
+interface for file names has been changed to be more consistent.
+
+**Interface Changes**
+
+ - `SerialDataCollector` file name interface changed #242
+ - `writeAttribute()` now creates missing groups recursively #231 #250
+
+**Bug Fixes**
+
+ - throw more exceptions on wrong usage of `ParallelDataCollector` #247
+
+**Misc**
+
+ - compiling via `-Werror` is not shipped any more #251
+ - python tools: indentiation cleanup #249
+ - `generateCollectionType` refactored, docs fixed #243 #246
+
+
 Release 1.4.0
 -------------
 **Date:** 2016-04-12

CMakeLists.txt

@@ -87,7 +87,7 @@ UNSET(HDF5_HAS_SHARED_POS)
 
 #-------------------------------------------------------------------------------
 
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wextra -Woverloaded-virtual")
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Woverloaded-virtual")
 
 # options
 OPTION(DEBUG_VERBOSE "Enable verbose HDF5 debug output" OFF)
@@ -111,7 +111,8 @@ ENDIF(NOT SPLASH_RELEASE)
 SET(SPLASH_LIBS z ${HDF5_LIBRARIES})
 
 # serial or parallel version of libSplash
-SET(SPLASH_CLASSES logging DCAttribute DCDataSet DCGroup HandleMgr SerialDataCollector DomainCollector SDCHelper)
+SET(SPLASH_CLASSES logging DCAttribute DCDataSet DCGroup HandleMgr SerialDataCollector
+    DomainCollector SDCHelper generateCollectionType)
 IF(HDF5_IS_PARALLEL)
     #parallel version
     MESSAGE(STATUS "Parallel HDF5 found. Building parallel version")

README.md

@@ -15,8 +15,8 @@ Introduction
 I/O library for HPC simulations. It is created as an easy-to-use frontend for the
 standard HDF5 library with support for MPI processes in a cluster environment.
 While the standard HDF5 library provides detailed low-level control, libSplash
-simplifies tasks commonly found in large-scale HPC simulations, such as iter-
-ative computations and MPI distributed processes.
+simplifies tasks commonly found in large-scale HPC simulations, such as
+iterative computations and MPI distributed processes.
 
 
 libSplash is developed and maintained by the

src/ParallelDataCollector.cpp

@@ -470,6 +470,9 @@ namespace splash
         if (ndims < 1u || ndims > DSP_DIM_MAX)
             throw DCException(getExceptionString("writeAttribute", "maximum dimension `ndims` is invalid"));
 
+        /* group_path: absolute path to the last inode
+         * obj_name: last inode, can be a group or a dataset
+         */
         std::string group_path, obj_name;
         std::string dataNameInternal = "";
         if (dataName)
@@ -479,6 +482,16 @@ namespace splash
         DCParallelGroup group;
         if (dataName)
         {
+            /* if the specified inode (obj_name) does not exist
+             * (as dataset or group), create all missing groups along group_path
+             * and even create an empty group for obj_name itself
+             *
+             * group_path + "/" + obj_name is the absolute path of dataName
+             */
+            std::string pathAndName(group_path + "/" + obj_name);
+            if(!DCParallelGroup::exists(handles.get(id), pathAndName))
+                group.create(handles.get(id), pathAndName);
+
             // attach attribute to the dataset or group
             group.open(handles.get(id), group_path);
             hid_t obj_id = H5Oopen(group.getHandle(), obj_name.c_str(), H5P_DEFAULT);
@@ -774,33 +787,6 @@ namespace splash
         src_dataset.close();
     }
 
-    void ParallelDataCollector::createReference(int32_t srcID,
-            const char *srcName,
-            int32_t dstID,
-            const char *dstName,
-            Dimensions /*count*/,
-            Dimensions /*offset*/,
-            Dimensions /*stride*/)
-    throw (DCException)
-    {
-        if (srcName == NULL || dstName == NULL)
-            throw DCException(getExceptionString("createReference", "a parameter was NULL"));
-
-        if (fileStatus == FST_CLOSED || fileStatus == FST_READING)
-            throw DCException(getExceptionString("createReference", "this access is not permitted"));
-
-        if (srcID != dstID)
-            throw DCException(getExceptionString("createReference",
-                "source and destination ID must be identical", NULL));
-
-        if (srcName == dstName)
-            throw DCException(getExceptionString("createReference",
-                "a reference must not be identical to the referenced data", srcName));
-
-        throw DCException(getExceptionString("createReference",
-                "feature currently not supported by Parallel HDF5", NULL));
-    }
-
     /*******************************************************************************
      * PROTECTED FUNCTIONS
      *******************************************************************************/
@@ -1143,4 +1129,56 @@ namespace splash
         dataset.close();
     }
 
+    /* UNIMPLEMENTED METHODS FROM DATACOLLECTOR. TODO: Unify interface to remove those */
+    void ParallelDataCollector::readGlobalAttribute(const char*, void*, Dimensions*)
+    throw (DCException)
+    {
+        throw DCException(getExceptionString("readGlobalAttribute",
+                "feature currently not supported by Parallel HDF5"));
+    }
+
+    void ParallelDataCollector::writeGlobalAttribute(const CollectionType& /*type*/,
+            const char* /*name*/, const void* /*data*/) throw (DCException)
+    {
+        throw DCException(getExceptionString("readGlobalAttribute",
+                "feature currently not supported by Parallel HDF5"));
+    }
+
+    void ParallelDataCollector::writeGlobalAttribute(const CollectionType& /*type*/,
+            const char* /*name*/, uint32_t /*ndims*/, const Dimensions /*dims*/,
+            const void* /*data*/) throw (DCException)
+    {
+        throw DCException(getExceptionString("readGlobalAttribute",
+                "feature currently not supported by Parallel HDF5"));
+    }
+
+    void ParallelDataCollector::append(int32_t /*id*/, const CollectionType& /*type*/,
+            size_t /*count*/, const char* /*name*/, const void* /*data*/)
+    throw (DCException)
+    {
+        throw DCException(getExceptionString("readGlobalAttribute",
+                "feature currently not supported by Parallel HDF5"));
+    }
+
+    void ParallelDataCollector::append(int32_t /*id*/, const CollectionType& /*type*/,
+            size_t /*count*/, size_t /*offset*/, size_t /*stride*/, const char* /*name*/,
+            const void* /*data*/) throw (DCException)
+    {
+        throw DCException(getExceptionString("readGlobalAttribute",
+                "feature currently not supported by Parallel HDF5"));
+    }
+
+    void ParallelDataCollector::createReference(int32_t /*srcID*/,
+            const char */*srcName*/,
+            int32_t /*dstID*/,
+            const char */*dstName*/,
+            Dimensions /*count*/,
+            Dimensions /*offset*/,
+            Dimensions /*stride*/)
+    throw (DCException)
+    {
+        throw DCException(getExceptionString("readGlobalAttribute",
+                "feature currently not supported by Parallel HDF5"));
+    }
+
 }

src/SerialDataCollector.cpp

@@ -369,6 +369,9 @@ namespace splash
         if (ndims < 1u || ndims > DSP_DIM_MAX)
             throw DCException(getExceptionString("writeAttribute", "maximum dimension `ndims` is invalid"));
 
+        /* group_path: absolute path to the last inode
+         * obj_name: last inode, can be a group or a dataset
+         */
         std::string group_path, obj_name;
         std::string dataNameInternal = "";
         if (dataName)
@@ -378,6 +381,16 @@ namespace splash
         DCGroup group;
         if (dataName)
         {
+            /* if the specified inode (obj_name) does not exist
+             * (as dataset or group), create all missing groups along group_path
+             * and even create an empty group for obj_name itself
+             *
+             * group_path + "/" + obj_name is the absolute path of dataName
+             */
+            std::string pathAndName(group_path + "/" + obj_name);
+            if(!DCGroup::exists(handles.get(id), pathAndName))
+                group.create(handles.get(id), pathAndName);
+
             // attach attribute to the dataset or group
             group.open(handles.get(0), group_path);
 

src/generateCollectionType.cpp

@@ -0,0 +1,135 @@
+/**
+ * Copyright 2015-2016 Carlchristian Eckert, Alexander Grund
+ *
+ * This file is part of libSplash.
+ *
+ * libSplash is free software: you can redistribute it and/or modify
+ * it under the terms of of either the GNU General Public License or
+ * the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libSplash is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License and the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the GNU Lesser General Public License along with libSplash.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GENERATE_COLLECTION_TYPE_H
+#define GENERATE_COLLECTION_TYPE_H
+
+
+#include "splash/basetypes/generateCollectionType.hpp"
+#include "splash/basetypes/basetypes.hpp"
+#include <typeinfo>
+#include <cassert>
+
+namespace splash
+{
+
+/**
+ * Checks if a datatype_id (from an outer scope) can be used to generate a
+ * specific CollectionType instance.
+ *
+ * If the call to the genType member function of a specific collection type
+ * is successful, it will return the pointer to an instance of this type.
+ *
+ * @param _name the suffix of the ColType. i.e. to check for ColTypeBool,
+ * _name should be set to Bool.
+ */
+#define TRY_COLTYPE(_name)                                                     \
+{                                                                              \
+    CollectionType* t = ColType##_name::genType(datatype_id);                  \
+    assert(t == NULL || typeid(*t) == typeid(ColType##_name));                 \
+    if(t != NULL) return t;                                                    \
+}                                                                              \
+
+
+/**
+ * Creates a new instance of a CollectionType based on the given datatype_id
+ *
+ * @param datatype_id the H5 datatype_id that should be converted into a
+ *                    CollectionType
+ *
+ * @return A pointer to a heap-allocated CollectionType.
+ *         The allocated object must be freed by the caller at the end of its
+ *         lifetime.
+ *         If no matching CollectionType was found, returns a ColTypeUnknown
+ *         instance.
+ */
+CollectionType* generateCollectionType(hid_t datatype_id)
+{
+    // basetypes atomic
+    TRY_COLTYPE(Int8)
+    TRY_COLTYPE(Int16)
+    TRY_COLTYPE(Int32)
+    TRY_COLTYPE(Int64)
+
+    TRY_COLTYPE(UInt8)
+    TRY_COLTYPE(UInt16)
+    TRY_COLTYPE(UInt32)
+    TRY_COLTYPE(UInt64)
+
+    TRY_COLTYPE(Float)
+    TRY_COLTYPE(Double)
+    TRY_COLTYPE(Char)
+    TRY_COLTYPE(Int)
+
+
+    // ColType Bool -> must be before the other enum types!
+    TRY_COLTYPE(Bool)
+
+
+    // ColType String
+    TRY_COLTYPE(String)
+
+
+    // ColTypeArray()
+    TRY_COLTYPE(Float2Array)
+    TRY_COLTYPE(Float3Array)
+    TRY_COLTYPE(Float4Array)
+
+    TRY_COLTYPE(Double2Array)
+    TRY_COLTYPE(Double3Array)
+    TRY_COLTYPE(Double4Array)
+
+    TRY_COLTYPE(Int4Array)
+    TRY_COLTYPE(Int3Array)
+    TRY_COLTYPE(Int2Array)
+
+
+    // ColTypeDimArray
+    TRY_COLTYPE(DimArray)
+
+
+    // ColType Dim
+    TRY_COLTYPE(Dim)
+
+
+    // Coltype Compound
+    TRY_COLTYPE(Float2)
+    TRY_COLTYPE(Float3)
+    TRY_COLTYPE(Float4)
+
+    TRY_COLTYPE(Double2)
+    TRY_COLTYPE(Double3)
+    TRY_COLTYPE(Double4)
+
+    TRY_COLTYPE(Int2)
+    TRY_COLTYPE(Int3)
+    TRY_COLTYPE(Int4)
+
+    return new ColTypeUnknown;
+}
+
+#undef TRY_COLTYPE
+
+} /* namespace splash */
+
+
+#endif /* GENERATE_COLLECTION_TYPE_H */

src/include/splash/DataCollector.hpp

@@ -366,6 +366,7 @@ namespace splash
          * @param type Type information for data.
          * @param dataName Name of the dataset in group \p id to write attribute to.
          * If dataName is NULL, the attribute is written for the iteration group.
+         * If the path dataName does not yet exist, missing groups will be created.
          * @param attrName Name of the attribute.
          * @param buf Buffer to be written as attribute.
          */