Hello community,
here is the log from the commit of package parallel-netcdf for openSUSE:Factory checked in at 2015-08-03 17:22:26
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/parallel-netcdf (Old)
and /work/SRC/openSUSE:Factory/.parallel-netcdf.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "parallel-netcdf"
Changes:
--------
New Changes file:
--- /dev/null 2015-07-22 21:25:44.928025004 +0200
+++ /work/SRC/openSUSE:Factory/.parallel-netcdf.new/parallel-netcdf.changes 2015-08-03 17:22:27.000000000 +0200
@@ -0,0 +1,607 @@
+-------------------------------------------------------------------
+Mon Aug 3 09:38:24 UTC 2015 - toddrme2178@gmail.com
+
+- Fix license
+
+-------------------------------------------------------------------
+Tue Jul 28 16:06:23 UTC 2015 - toddrme2178@gmail.com
+
+- Fix building on non-x86_64 64-bit platforms
+
+-------------------------------------------------------------------
+Mon Jul 27 11:11:12 UTC 2015 - toddrme2178@gmail.com
+
+- Update subpackage groups
+- Make subpackage summaries and descriptions more consistent
+- Provide rpm macros for version identification
+- Spec file cleanups
+
+-------------------------------------------------------------------
+Wed Jul 15 09:30:58 UTC 2015 - toddrme2178@gmail.com
+
+- Update to version 1.6.1
+ o New features
+ * PnetCDF now supports fill mode. ncmpi_set_fill() can be used to set the
+ fill mode for the entire data set. Note the differences from netCDF:
+ 1. The default mode in PnetCDF is NC_NOFILL.
+ 2. Setting fill mode for the entire file or individual variables must be
+ done in define mode.
+ 3. For non-record variables, they are filled at the time ncmpi_enddef()
+ is called.
+ 4. For record variables, users must explicitly call ncmpi_fill_var_rec()
+ to fill one record at a time before writing to the record of that
+ variable.
+ o New APIs
+ * ncmpi_def_var_fill() sets fill mode for an individual variable. This API
+ must be called in define mode.
+ * ncmpi_inq_var_fill() inquires fill mode of a variable.
+ * ncmpi_fill_var_rec() is a collective API that fills a record of a record
+ variable. This API must be called at data mode.
+ * ncmpi_inq_default_format() for inquiring the default file format for
+ new file creation. Note the default format can be changed by
+ ncmpi_set_default_format().
+ * The above new API are also available in Fortran and C++ versions.
+ o New error code
+ * NC_ENOTRECVAR when attempting operation only for record variables
+ * NC_ENOTFILL when attempting to fill a variable when its fill mode is off
+ * NC_EMULTIDEFINE_FILL_MODE when inconsistent dataset fill mode is detected
+ * NC_EMULTIDEFINE_VAR_FILL_MODE when inconsistent variable fill mode is
+ detected
+ * NC_EMULTIDEFINE_VAR_FILL_VALUE when inconsistent variable fill value is
+ detected
+ * Fortran versions of the above error codes are also added.
+ o New example programs
+ * C/fill_mode.c shows the use of ncmpi_set_fill(), ncmpi_def_var_fill(),
+ ncmpi_inq_var_fill() and ncmpi_fill_var_rec()
+ F77/fill_mode.f is the Fortran version.
+ F90/fill_mode.f90 is the Fortran 90 version.
+ CXX/fill_mode.cpp is the C++ version.
+ * C/ghost_cell.c shows how to use varm API for writing from a user buffer
+ as a 2D array with ghost cells on both ends of every dimension.
+ o New test programs
+ * nc_test/tst_nofill.c borrowed from netCDF
+ * testcases/ivarn.c tests bug fix r2023 when the request IDs stored in
+ argument array_of_requests[] of ncmpi_wait_all() are not in an
+ increasing order.
+ o Other updates:
+ * Change the chunk size used for moving variable data when the file header
+ extent expands. The default is now 1MB. If the file's striping unit
+ size is known (from MPI-IO hint striping_unit) then the chunk size is
+ set to the striping unit size.
+ o Bug fixes
+ * Add missing F90 function overloading for f90mpi_put_var_all,
+ f90mpi_get_var_all, f90mpi_put_vard_all, and f90mpi_get_vard_all,
+ when the user buffer is a scalar.
+ * Fix when the request IDs passed in argument array_of_requests[] of
+ ncmpi_wait_all() are not in an increasing order. See r2023.
+ * Fix C++ compile error for converting NULL to string. See r2039.
+- Update to version 1.6.0
+ o Format conformation updates:
+ * Conform with netCDF4 on CDF-1 and CDF-2 formats. The only difference now
+ between the two formats are the OFFSET item in the format spec (32 vs.
+ 64 bit integers.) All names (variable, dimension, attribute) now allow
+ extended characters (eg. special2 and MUTF8).
+ o New APIs
+ * Nonblocking buffered varn API family.
+ For C, ncmpi_bput_varn_<type>()
+ For F77, nfmpi_bput_varn_<type>()
+ For F90, nf90mpi_bput_varn()
+ For C++, NcmpiVar::bputVarn()
+ * Nonblocking varn API family.
+ For C, ncmpi_iput_varn_<type>() and ncmpi_iget_varn_<type>()
+ For F77, nfmpi_iput_varn_<type>() and nfmpi_iget_varn_<type>()
+ For F90, nf90mpi_iput_varn() and nf90mpi_iget_varn()
+ For C++, NcmpiVar::iputVarn() and NcmpiVar::igetVarn()
+ * Blocking vard API family takes an argument of MPI derived data type that
+ describes the file access layout, as opposed to vara and vars APIs that
+ use start[] and count[].
+ For C, ncmpi_put_vard() and ncmpi_get_vard()
+ For F77, nfmpi_put_vard() and nfmpi_get_vard()
+ For F90, nf90mpi_put_vard() and nf90mpi_get_vard()
+ For C++, NcmpiVar::putVard() and NcmpiVar::getVard()
+ * Collective var1 API family
+ For C, ncmpi_put_var1_all() ncmpi_get_var1_all()
+ ncmpi_put_var1_<type>_all() ncmpi_get_var1_<type>_all()
+ For F77, nfmpi_put_var1_all() nfmpi_get_var1_all()
+ nfmpi_put_var1_<type>_all() nfmpi_get_var1_<type>_all()
+ For F90, nf90mpi_put_var_all() nf90mpi_get_var_all()
+ For C++, NcmpiVar::putVar_all() NcmpiVar::getVar_all()
+ * ncmpi_inq_buffer_size() returns the size of buffer previously attached
+ for use of bput APIs. With ncmpi_inq_buffer_usage() one can calculate
+ the space remaining for additional bput requests.
+ For F77, nfmpi_inq_buffer_size()
+ For F90, nf90mpi_inq_buffer_size()
+ For C++, NcmpiFile::Inq_buffer_size()
+ * ncmpi_inq_recsize() returns the size of record block, i.e. the sum of
+ single records of all record variables.
+ For F77, nfmpi_inq_recsize()
+ For F90, nf90mpi_inq_recsize()
+ For C++, NcmpiGroup::getRecSize()
+ * ncmpi_inq_num_rec_vars() and ncmpi_inq_num_fix_vars() report the number
+ of record and fixed-size variables, respectively.
+ For F77, nfmpi_inq_num_rec_vars() and nfmpi_inq_num_fix_vars()
+ For F90, nf90mpi_inq_num_rec_vars() and nf90mpi_inq_num_fix_vars()
+ For C++, NcmpiGroup::getRecVarCount() and NcmpiGroup::getFixVarCount()
+ o New PnetCDF hint
+ * pnetcdf_subfiling -- it can be set in an MPI info object or in the
+ environment variable PNETCDF_HINTS to enable/disable subfiling.
+ The value is either "enable" or "disable".
+ o PnetCDF hint priority
+ * The alignment hints set in the environment variable "PNETCDF_HINTS" have
+ the highest priority, which overwrite the alignment hints set in
+ ncmpi__enddef(), which overwrite the alignment hints set in the MPI_Info
+ object used in the call of ncmpi_create() and ncmpi_open().
+ o New error code
+ * NC_ESTRICTCDF2 for attempting CDF-5 operation on CDF-2 file. For
+ example, define a variable of type NC_INT64 in a CDF-2 file.
+ * NC_ETYPESIZE when filetype size is bigger than the variable size
+ * NC_ETYPE_MISMATCH when the element type of filetype mismatches the
+ variable type
+ * NC_ETYPESIZE_MISMATCH when filetype size mismatches buffer type size
+ * NC_ENULLSTART when argument start is a NULL pointer
+ * NC_ENULLCOUNT when argument count is a NULL pointer
+ * NC_EINVAL_CMODE when invalid file create mode is set, (e.g. cannot have
+ both NC_64BIT_OFFSET & NC_64BIT_DATA. In PnetCDF 1.5.0 and earlier
+ versions, if both flags were set, then NC_64BIT_DATA triumphs
+ NC_64BIT_OFFSET.)
+ o New example programs
+ * C/bput_varn_uint.c and F77/bput_varn_int8.f show the use of
+ nonblocking bput_varn APIs
+ * C/i_varn_int64.c and F77/i_varn_real.f show the use of nonblocking
+ iput_varn and iget_varn APIs
+ * C/vard_int.c F77/vard_int.f F90/vard_int.f90 CXX/vard_int.cpp show the
+ use of vard API to write/read record and fixed-size variables.
+ * C/transpose.c shows the use of ncmpi_put_vara_int_all to write a 3D array
+ that is dimensional-transposed from the one stored in memory. Six
+ transposed 3D arrays are saved whose dimensions are organized as ZYX,
+ ZXY, YZX, YXZ, XZY, and XYZ. The C++, Fortran 77, and Fortran 90
+ versions are also provided.
+ o New test program
+ * nonblocking/wait_after_indep.c tests if ncmpi_end_indep_data() returns
+ properly when nonblocking APIs are called in independent data mode and
+ the wait call is made after exiting the independent mode.
+ * nonblocking/flexible_bput.c tests flexible bput APIs that use
+ noncontiguous buffer type, noncontiguous imap and require type conversion
+ * testcases/flexible2.c tests flexible APIs that perform type conversion
+ * testcases/flexible_varm.c tests flexible varm APIs
+ * testcases/varn_contig.c tests the case when the fileview is actually a
+ contiguous chunk. PnetCDF should be able to merge all.
+ * nonblocking/bput_varn_uint.c tests nonblocking bput_varn APIs
+ * nonblocking/i_varn_int64.c tests nonblocking iput_varn and iget_varn APIs
+ * test/testcases/test_vard.c test/testcases/test_vardf.f
+ test/testcases/test_vardf90.f90 test the new vard APIs.
+ * test/testcases/inq_recsize.c tests if one can correctly inquire the
+ size of record block from in a netCDF file. A similar program in F90,
+ named inq_recsizef.f90, is also added.
+ * In test/nc_test, the test programs below are borrowed from netCDF test
+ programs: t_nc.c tst_misc.c tst_norm.c tst_small.c tst_names.c
+ tst_atts3.c tst_atts.c
+ * test/testcases/one_record.c tests the special case defined in CDF-1 and
+ CDF-2 specification that "A special case: Where there is exactly one
+ record variable, we drop the requirement that each record be four-byte
+ aligned, so in this case there is no record padding."
+ * test/testcases/modes.c tests if correct error codes are returned when
+ various file create/open modes are used.
+ * Under test/testcases, varn_int.c varn_intf.f varn_real.f90 test varn APIs
+ * test/testcases/inq_num_vars.c test if one can correctly inquire the
+ numbers of record and fixed-size variables defined in a netCDF file.
+ A similar program in F90, named inq_num_varsf.f90, is also added.
+ * test/nonblocking/interleaved.c tests a combination of interleaved
+ file types. This is to test the bug fix in r1758.
+ o New optimization
+ * Prior to this release, PnetCDF wraps each MPI read/write call in put/get
+ APIs with two MPI_File_set_view(). One is before the MPI read/write call
+ to take advantage of MPI's fileview feature for accessing non-contiguous
+ file locations. The other is after the MPI read/write call to make the
+ whole file visible, as the root process may write to file header later
+ in the data mode and it alone cannot make a call to MPI_File_set_view()
++++ 410 more lines (skipped)
++++ between /dev/null
++++ and /work/SRC/openSUSE:Factory/.parallel-netcdf.new/parallel-netcdf.changes
New:
----
parallel-netcdf-1.6.1-destdir.patch
parallel-netcdf-1.6.1.tar.bz2
parallel-netcdf.changes
parallel-netcdf.spec
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ parallel-netcdf.spec ++++++
#
# spec file for package parallel-netcdf
#
# Copyright (c) 2015 SUSE LINUX Products GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
# upon. The license for this file, and modifications and additions to the
# file, is the same license as for the pristine package itself (unless the
# license for the pristine package is not an Open Source License, in which
# case the license is the MIT License). An "Open Source License" is a
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.
# Please submit bugfixes or comments via http://bugs.opensuse.org/
#
%if 0%{?sles_version}
%define _mvapich2 1
%endif
%if 0%{?suse_version}
%define _openmpi 1
%endif
%define _mpi %{?_openmpi:openmpi} %{?_mvapich2:mvapich2}
Name: parallel-netcdf
%define libname libpnetcdf
Version: 1.6.1
Release: 0
%define sonum 1
Summary: High-performance parallel I/O with the NetCDF scientific data format
License: NetCDF
Group: Productivity/Scientific/Other
Url: http://cucis.ece.northwestern.edu/projects/PnetCDF/index.html
Source0: http://cucis.ece.northwestern.edu/projects/PnetCDF/Release/%{name}-%{version}.tar.bz2
# PATCH-FIX-OPENSUSE parallel-netcdf-1.6.1-destdir.patch Fix install directories
Patch0: parallel-netcdf-1.6.1-destdir.patch
BuildRequires: bison
BuildRequires: flex
BuildRequires: gcc-c++
BuildRequires: gcc-fortran
%if 0%{?_openmpi}
BuildRequires: openmpi-devel
%endif
%if 0%{?_mvapich2}
BuildRequires: mvapich2-devel
%endif
BuildRoot: %{_tmppath}/%{name}-%{version}-build
%description
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
%package openmpi
Summary: High-performance parallel I/O with the NetCDF scientific data format
Group: Productivity/Scientific/Other
Requires: %{libname}%{sonum}-openmpi = %{version}
%description openmpi
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains the openmpi version of utility functions for
working with NetCDF files.
%package mvapich2
Summary: High-performance parallel I/O with the NetCDF scientific data format
Group: Productivity/Scientific/Other
Requires: %{libname}%{sonum}-mvapich2 = %{version}
%description mvapich2
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains the mvapich2 version of utility functions for
working with NetCDF files.
%package -n %{libname}%{sonum}-openmpi
Summary: High-performance parallel I/O with the NetCDF scientific data format
Group: Productivity/Scientific/Other
Provides: %{libname}-openmpi = %{version}
%description -n %{libname}%{sonum}-openmpi
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains the openmpi version of the PnetCDF runtime
libraries.
%package -n %{libname}%{sonum}-mvapich2
Summary: High-performance parallel I/O with the NetCDF scientific data format
Group: Productivity/Scientific/Other
Provides: %{libname}-mvapich2 = %{version}
%description -n %{libname}%{sonum}-mvapich2
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains the mvapich2 version of the PnetCDF runtime
libraries.
%package devel-data
Summary: Development data files for %{name}
Group: Development/Libraries/Parallel
%description devel-data
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains generic files needed to create projects that use
any version of PnetCDF.
%package openmpi-devel
Summary: Development files for %{name}-openmpi
Group: Development/Libraries/Parallel
Requires: openmpi-devel
Requires: %{libname}%{sonum}-openmpi = %{version}
%description openmpi-devel
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains all files needed to create projects that use
the openmpi version of PnetCDF.
%package mvapich2-devel
Summary: Development files for %{name}-mvapich2
Group: Development/Libraries/Parallel
Requires: mvapich2-devel
Requires: %{libname}%{sonum}-mvapich2 = %{version}
%description mvapich2-devel
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains all files needed to create projects that use
the mvapich2 version of PnetCDF.
%package openmpi-devel-static
Summary: Static development files for %{name}-openmpi
Group: Development/Libraries/Parallel
Requires: %{name}-openmpi-devel = %{version}
%description openmpi-devel-static
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains the openmpi versions of the static libraries
for PnetCDF.
%package mvapich2-devel-static
Summary: Static development files for %{name}-mvapich2
Group: Development/Libraries/Parallel
Requires: %{name}-mvapich2-devel = %{version}
%description mvapich2-devel-static
NetCDF is a set of software libraries and self-describing,
machine-independent data formats that support the creation, access,
and sharing of array-oriented scientific data.
NetCDF (network Common Data Form) is an interface for array-oriented
data access and a freely-distributed collection of software libraries
for C, Fortran, C++, and perl that provides an implementation of the
interface. The NetCDF library also defines a machine-independent
format for representing scientific data. Together, the interface,
library, and format support the creation, access, and sharing of
scientific data. The NetCDF software was developed at the Unidata
Program Center in Boulder, Colorado.
NetCDF data is:
- Self-Describing: A NetCDF file includes information about the
data it contains.
- Network-transparent: A NetCDF file is represented in a form that
can be accessed by computers with different ways of storing
integers, characters, and floating-point numbers.
- Direct-access: A small subset of a large dataset may be accessed
efficiently, without first reading through all the preceding
data.
- Appendable: Data can be appended to a NetCDF dataset along one
dimension without copying the dataset or redefining its
structure. The structure of a NetCDF dataset can be changed,
though this sometimes causes the dataset to be copied.
- Sharable: One writer and multiple readers may simultaneously
access the same NetCDF file.
Parallel netCDF (PnetCDF) is a library providing high-performance I/O while
still maintaining file-format compatibility with Unidata's NetCDF.
This package contains the mvapich2 versions of the static libraries
for PnetCDF.
%prep
%setup -q -n %{name}-%{version}
%patch0 -p1
set -- *
for mpi in %_mpi; do
mkdir $mpi
mkdir $mpi/shared
cp -ap "$@" $mpi
done
%build
for mpi in %_mpi; do
pushd $mpi
%configure --prefix=%{_libdir}/mpi/gcc/$mpi \
--libdir=%{_libdir}/mpi/gcc/$mpi/%{_lib} \
--with-mpi=%{_libdir}/mpi/gcc/$mpi
make
pushd shared
%{_libdir}/mpi/gcc/$mpi/bin/mpif77 -shared -Wl,-soname=libpnetcdf.so.%{sonum} -o ../libpnetcdf.so.%{version}
popd
popd
done
%install
for mpi in %_mpi; do
pushd $mpi
%make_install
%if %{_lib} != lib
mv %{buildroot}%{_libdir}/mpi/gcc/$mpi/lib %{buildroot}%{_libdir}/mpi/gcc/$mpi/%{_lib}
%endif
install -m 755 libpnetcdf.so.%{version} %{buildroot}%{_libdir}/mpi/gcc/$mpi/%{_lib}
pushd %{buildroot}%{_libdir}/mpi/gcc/$mpi/%_lib
ln -s libpnetcdf.so.%{version} libpnetcdf.so.%{sonum}
ln -s libpnetcdf.so.%{version} libpnetcdf.so
popd
find %{buildroot} -name '*.la' -exec rm {} \;
popd
done
# rpm macro for version checking
mkdir -p %{buildroot}%{_sysconfdir}/rpm
cat > %{buildroot}%{_sysconfdir}/rpm/macros.pnetcdf <