Hello community,
here is the log from the commit of package ghc-accelerate for openSUSE:Factory
checked in at 2017-08-31 20:46:10
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-accelerate (Old)
and /work/SRC/openSUSE:Factory/.ghc-accelerate.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-accelerate"
Thu Aug 31 20:46:10 2017 rev:2 rq:513198 version:1.0.0.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/ghc-accelerate/ghc-accelerate.changes
2016-09-25 14:30:56.000000000 +0200
+++ /work/SRC/openSUSE:Factory/.ghc-accelerate.new/ghc-accelerate.changes
2017-08-31 20:46:12.337841163 +0200
@@ -1,0 +2,5 @@
+Thu Jul 27 14:07:20 UTC 2017 - psim...@suse.com
+
+- Update to version 1.0.0.0 revision 1.
+
+-------------------------------------------------------------------
Old:
----
1.cabal
accelerate-0.15.1.0.tar.gz
New:
----
accelerate-1.0.0.0.tar.gz
accelerate.cabal
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ ghc-accelerate.spec ++++++
--- /var/tmp/diff_new_pack.5YgF4u/_old 2017-08-31 20:46:13.809634577 +0200
+++ /var/tmp/diff_new_pack.5YgF4u/_new 2017-08-31 20:46:13.813634016 +0200
@@ -1,7 +1,7 @@
#
# spec file for package ghc-accelerate
#
-# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -18,27 +18,34 @@
%global pkg_name accelerate
Name: ghc-%{pkg_name}
-Version: 0.15.1.0
+Version: 1.0.0.0
Release: 0
Summary: An embedded language for accelerated array processing
License: BSD-3-Clause
-Group: System/Libraries
+Group: Development/Languages/Other
Url: https://hackage.haskell.org/package/%{pkg_name}
Source0:
https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz
-Source1:
https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/1.cabal
+Source1:
https://hackage.haskell.org/package/%{pkg_name}-%{version}/revision/1.cabal#/%{pkg_name}.cabal
BuildRequires: ghc-Cabal-devel
-# Begin cabal-rpm deps:
-BuildRequires: ghc-array-devel
+BuildRequires: ghc-base-orphans-devel
BuildRequires: ghc-containers-devel
+BuildRequires: ghc-deepseq-devel
+BuildRequires: ghc-directory-devel
+BuildRequires: ghc-exceptions-devel
BuildRequires: ghc-fclabels-devel
+BuildRequires: ghc-filepath-devel
BuildRequires: ghc-hashable-devel
BuildRequires: ghc-hashtables-devel
+BuildRequires: ghc-mtl-devel
BuildRequires: ghc-pretty-devel
BuildRequires: ghc-rpm-macros
BuildRequires: ghc-template-haskell-devel
+BuildRequires: ghc-time-devel
+BuildRequires: ghc-transformers-devel
+BuildRequires: ghc-unique-devel
+BuildRequires: ghc-unix-devel
BuildRequires: ghc-unordered-containers-devel
BuildRoot: %{_tmppath}/%{name}-%{version}-build
-# End cabal-rpm deps
%description
'Data.Array.Accelerate' defines an embedded array language for computations for
@@ -58,58 +65,55 @@
Except for the type, this code is almost the same as the corresponding Haskell
code on lists of floats. The types indicate that the computation may be
online-compiled for performance - for example, using
-'Data.Array.Accelerate.CUDA' it may be on-the-fly off-loaded to the GPU.
+'Data.Array.Accelerate.LLVM.PTX' it may be on-the-fly off-loaded to the GPU.
-[/Available backends/]
+[/Additional components/]
-Currently, there are two backends:
+The following supported add-ons are available as separate packages.
+Install them from Hackage with 'cabal install <package>'
-1. An interpreter that serves as a reference implementation of the intended
-semantics of the language, which is included in this package.
+* 'accelerate-llvm-native': Backend supporting parallel execution on multicore
+CPUs.
-2. A CUDA backend generating code for CUDA-capable NVIDIA GPUs:
-<http://hackage.haskell.org/package/accelerate-cuda>
+* 'accelerate-llvm-ptx': Backend supporting parallel execution on CUDA-capable
+NVIDIA GPUs. Requires a GPU with compute capability 2.0 or greater.
+See the following table for supported GPUs:
+<http://en.wikipedia.org/wiki/CUDA#Supported_GPUs>
-Several experimental and/or incomplete backends also exist. If you are
-particularly interested in any of these, especially with helping to finish
-them, please contact us.
+* 'accelerate-cuda': Backend targeting CUDA-enabled NVIDIA GPUs.
+Requires a GPU with compute compatibility 1.2 or greater. /NOTE: This backend
+is being deprecated in favour of 'accelerate-llvm-ptx'./
-1. Cilk/ICC and OpenCL:
-<https://github.com/AccelerateHS/accelerate-backend-kit>
+* 'accelerate-examples': Computational kernels and applications showcasing the
+use of Accelerate as well as a regression test suite, supporting function and
+performance testing.
-2. Another OpenCL backend: <https://github.com/HIPERFIT/accelerate-opencl>
+* 'accelerate-io': Fast conversions between Accelerate arrays and other array
+formats (including vector and repa).
-3. A backend to the Repa array library:
-<https://github.com/blambo/accelerate-repa>
+* 'accelerate-fft': Discrete Fourier transforms, with FFI bindings to optimised
+implementations.
-4. An infrastructure for generating LLVM code, with backends targeting
-multicore CPUs and NVIDIA GPUs:
-<https://github.com/AccelerateHS/accelerate-llvm/>
+* 'accelerate-bignum': Fixed-width large integer arithmetic.
-[/Additional components/]
+* 'colour-accelerate': Colour representations in Accelerate (RGB, sRGB, HSV,
+and HSL).
-The following support packages are available:
-
-1. 'accelerate-cuda': A high-performance parallel backend targeting
-CUDA-enabled NVIDIA GPUs. Requires the NVIDIA CUDA SDK and, for full
-functionality, hardware with compute capability 1.1 or greater. See the table
-on Wikipedia for supported GPUs:
-<http://en.wikipedia.org/wiki/CUDA#Supported_GPUs>
+* 'gloss-accelerate': Generate gloss pictures from Accelerate.
-2. 'accelerate-examples': Computational kernels and applications showcasing
-/Accelerate/, as well as performance and regression tests.
+* 'gloss-raster-accelerate': Parallel rendering of raster images and
+animations.
-3. 'accelerate-io': Fast conversion between /Accelerate/ arrays and other
-formats, including 'vector' and 'repa'.
+* 'lens-accelerate': Lens operators for Accelerate types.
-4. 'accelerate-fft': Computation of Discrete Fourier Transforms.
+* 'linear-accelerate': Linear vector spaces in Accelerate.
-Install them from Hackage with 'cabal install PACKAGE'
+* 'mwc-random-accelerate': Generate Accelerate arrays filled with high quality
+pseudorandom numbers.
[/Examples and documentation/]
-Haddock documentation is included in the package, and a tutorial is available
-on the GitHub wiki: <https://github.com/AccelerateHS/accelerate/wiki>
+Haddock documentation is included in the package
The 'accelerate-examples' package demonstrates a range of computational kernels
and several complete applications, including:
@@ -122,11 +126,20 @@
* An /n/-body simulation of gravitational attraction between solid particles
+* An implementation of the PageRank algorithm
+
+* A simple interactive ray tracer
+
+* A particle based simulation of stable fluid flows
+
* A cellular automata simulation
* A "password recovery" tool, for dictionary lookup of MD5 hashes
-* A simple interactive ray tracer
+'lulesh-accelerate' is an implementation of the Livermore Unstructured
+Lagrangian Explicit Shock Hydrodynamics (LULESH) mini-app. LULESH represents a
+typical hydrodynamics code such as ALE3D, but is highly simplified and
+hard-coded to solve the Sedov blast problem on an unstructured hexahedron mesh.
[/Mailing list and contacts/]
@@ -137,18 +150,7 @@
<http://groups.google.com/group/accelerate-haskell>
* Bug reports and issue tracking:
-<https://github.com/AccelerateHS/accelerate/issues>
-
-[/Hackage note/]
-
-The module documentation list generated by Hackage is incorrect. The only
-exposed modules should be:
-
-* "Data.Array.Accelerate"
-
-* "Data.Array.Accelerate.Interpreter"
-
-* "Data.Array.Accelerate.Data.Complex" .
+<https://github.com/AccelerateHS/accelerate/issues> .
%package devel
Summary: Haskell %{pkg_name} library development files
@@ -165,15 +167,12 @@
%setup -q -n %{pkg_name}-%{version}
cp -p %{SOURCE1} %{pkg_name}.cabal
-
%build
%ghc_lib_build
-
%install
%ghc_lib_install
-
%post devel
%ghc_pkg_recache
++++++ accelerate-0.15.1.0.tar.gz -> accelerate-1.0.0.0.tar.gz ++++++
++++ 29240 lines of diff (skipped)
++++++ accelerate.cabal ++++++
Name: accelerate
Version: 1.0.0.0
x-revision: 1
Cabal-version: >= 1.8
Tested-with: GHC >= 7.8
Build-type: Simple
Synopsis: An embedded language for accelerated array processing
Description:
@Data.Array.Accelerate@ defines an embedded array language for computations
for high-performance computing in Haskell. Computations on multi-dimensional,
regular arrays are expressed in the form of parameterised collective
operations, such as maps, reductions, and permutations. These computations may
then be online compiled and executed on a range of architectures.
.
[/A simple example/]
.
As a simple example, consider the computation of a dot product of two vectors
of floating point numbers:
.
> dotp :: Acc (Vector Float) -> Acc (Vector Float) -> Acc (Scalar Float)
> dotp xs ys = fold (+) 0 (zipWith (*) xs ys)
.
Except for the type, this code is almost the same as the corresponding Haskell
code on lists of floats. The types indicate that the computation may be
online-compiled for performance - for example, using
@Data.Array.Accelerate.LLVM.PTX@ it may be on-the-fly off-loaded to the GPU.
.
[/Additional components/]
.
The following supported add-ons are available as separate packages. Install
them from Hackage with @cabal install \<package\>@
.
* @accelerate-llvm-native@: Backend supporting parallel execution on
multicore CPUs.
.
* @accelerate-llvm-ptx@: Backend supporting parallel execution on
CUDA-capable NVIDIA GPUs. Requires a GPU with compute capability 2.0 or
greater. See the following table for supported GPUs:
<http://en.wikipedia.org/wiki/CUDA#Supported_GPUs>
.
* @accelerate-cuda@: Backend targeting CUDA-enabled NVIDIA GPUs. Requires
a GPU with compute compatibility 1.2 or greater. /NOTE: This backend is
being deprecated in favour of @accelerate-llvm-ptx@./
.
* @accelerate-examples@: Computational kernels and applications showcasing
the use of Accelerate as well as a regression test suite, supporting
function and performance testing.
.
* @accelerate-io@: Fast conversions between Accelerate arrays and other
array formats (including vector and repa).
.
* @accelerate-fft@: Discrete Fourier transforms, with FFI bindings to
optimised implementations.
.
* @accelerate-bignum@: Fixed-width large integer arithmetic.
.
* @colour-accelerate@: Colour representations in Accelerate (RGB, sRGB, HSV,
and HSL).
.
* @gloss-accelerate@: Generate gloss pictures from Accelerate.
.
* @gloss-raster-accelerate@: Parallel rendering of raster images and
animations.
.
* @lens-accelerate@: Lens operators for Accelerate types.
.
* @linear-accelerate@: Linear vector spaces in Accelerate.
.
* @mwc-random-accelerate@: Generate Accelerate arrays filled with high
quality pseudorandom numbers.
.
[/Examples and documentation/]
.
Haddock documentation is included in the package
.
The @accelerate-examples@ package demonstrates a range of computational
kernels and several complete applications, including:
.
* An implementation of the Canny edge detection algorithm
.
* An interactive Mandelbrot set generator
.
* A particle-based simulation of stable fluid flows
.
* An /n/-body simulation of gravitational attraction between solid particles
.
* An implementation of the PageRank algorithm
.
* A simple interactive ray tracer
.
* A particle based simulation of stable fluid flows
.
* A cellular automata simulation
.
* A \"password recovery\" tool, for dictionary lookup of MD5 hashes
.
@lulesh-accelerate@ is an implementation of the Livermore Unstructured
Lagrangian Explicit Shock Hydrodynamics (LULESH) mini-app. LULESH represents a
typical hydrodynamics code such as ALE3D, but is highly simplified and
hard-coded to solve the Sedov blast problem on an unstructured hexahedron
mesh.
.
[/Mailing list and contacts/]
.
* Mailing list: <accelerate-hask...@googlegroups.com> (discussion of both
use and development welcome).
.
* Sign up for the mailing list here:
<http://groups.google.com/group/accelerate-haskell>
.
* Bug reports and issue tracking:
<https://github.com/AccelerateHS/accelerate/issues>
.
License: BSD3
License-file: LICENSE
Author: Manuel M T Chakravarty,
Robert Clifton-Everest,
Gabriele Keller,
Ben Lever,
Trevor L. McDonell,
Ryan Newtown,
Sean Seefried
Maintainer: Trevor L. McDonell <tmcdon...@cse.unsw.edu.au>
Homepage: https://github.com/AccelerateHS/accelerate/
Bug-reports: https://github.com/AccelerateHS/accelerate/issues
Category: Compilers/Interpreters, Concurrency, Data, Parallelism
Stability: Experimental
Extra-source-files: changelog.md
Flag debug
Default: False
Description:
Enable debug tracing messages. The following options are read from the
environment variable @ACCELERATE_FLAGS@, and via the command-line as:
.
> ./program +ACC ... -ACC
.
Note that a backend may not implement (or be applicable to) all options.
.
The following flags control phases of the compiler. The are enabled with
@-f\<flag\>@ and can be reveresed with @-fno-\<flag\>@:
.
* @acc-sharing@: Enable sharing recovery of array expressions (True).
.
* @exp-sharing@: Enable sharing recovery of scalar expressions (True).
.
* @fusion@: Enable array fusion (True).
.
* @simplify@: Enable program simplification phase (True).
.
* @flush-cache@: Clear any persistent caches on program startup (False).
.
* @fast-math@: Allow algebraically equivalent transformations which may
change floating point results (e.g., reassociate) (True).
.
The following options control debug message output, and are enabled with
@-d\<flag\>@.
.
* @verbose@: Be extra chatty.
.
* @dump-phases@: Print timing information about each phase of the
compiler.
Enable GC stats (@+RTS -t@ or otherwise) for memory usage information.
.
* @dump-sharing@: Print information related to sharing recovery.
.
* @dump-simpl-stats@: Print statistics related to fusion & simplification.
.
* @dump-simpl-iterations@: Print a summary after each simplifier
iteration.
.
* @dump-vectorisation@: Print information related to the vectoriser.
.
* @dump-dot@: Generate a representation of the program graph in Graphviz
DOT format.
.
* @dump-simpl-dot@: Generate a more compact representation of the program
graph in Graphviz DOT format. In particular, scalar expressions are
elided.
.
* @dump-gc@: Print information related to the Accelerate garbage
collector.
.
* @dump-gc-stats@: Print aggregate garbage collection information at the
end of program execution.
.
* @dubug-cc@: Include debug symbols in the generated and compiled kernels.
.
* @dump-cc@: Print information related to kernel code
generation/compilation. Print the generated code if @verbose@.
.
* @dump-ld@: Print information related to runtime linking.
.
* @dump-asm@: Print information related to kernel assembly. Print the
assembled code if @verbose@.
.
* @dump-exec@: Print information related to program execution.
.
* @dump-sched@: Print information related to execution scheduling.
.
Flag ekg
Default: False
Description:
Enable hooks for monitoring the running application using EKG. Implies
@debug@ mode. In order to view the metrics, your application will need to
initialise the EKG server like so:
.
> import Data.Array.Accelerate.Debug
>
> import System.Metrics
> import System.Remote.Monitoring
>
> main :: IO ()
> main = do
> store <- initAccMetrics
> registerGcMetrics store -- optional
>
> server <- forkServerWith store "localhost" 8000
>
> ...
.
Note that, as with any program utilising EKG, in order to collect Haskell GC
statistics collection, you must either run the program with:
.
> +RTS -T -RTS
.
or compile it with:
.
> -with-rtsopts=-T
.
Flag bounds-checks
Description: Enable bounds checking
Default: True
Flag unsafe-checks
Description: Enable bounds checking in unsafe operations
Default: False
Flag internal-checks
Description: Enable internal consistency checks
Default: False
Library
Build-depends:
base >= 4.7 && < 4.11
, base-orphans >= 0.3
, containers >= 0.3
, deepseq >= 1.3
, directory >= 1.0
, exceptions >= 0.6
, fclabels >= 2.0
, filepath >= 1.0
, ghc-prim
, hashable >= 1.1
, hashtables >= 1.0
, mtl >= 2.0
, pretty >= 1.0
, template-haskell
, time >= 1.4
, transformers >= 0.3
, unique
, unordered-containers >= 0.2
Exposed-modules:
-- The core language and reference implementation
Data.Array.Accelerate
Data.Array.Accelerate.Interpreter
-- Prelude-like
Data.Array.Accelerate.Data.Bits
Data.Array.Accelerate.Data.Complex
Data.Array.Accelerate.Data.Fold
Data.Array.Accelerate.Data.Monoid
-- For backend development
Data.Array.Accelerate.AST
Data.Array.Accelerate.Analysis.Match
Data.Array.Accelerate.Analysis.Shape
Data.Array.Accelerate.Analysis.Stencil
Data.Array.Accelerate.Analysis.Type
Data.Array.Accelerate.Array.Data
Data.Array.Accelerate.Array.Remote
Data.Array.Accelerate.Array.Remote.Class
Data.Array.Accelerate.Array.Remote.LRU
Data.Array.Accelerate.Array.Remote.Table
Data.Array.Accelerate.Array.Representation
Data.Array.Accelerate.Array.Sugar
Data.Array.Accelerate.Array.Unique
Data.Array.Accelerate.Async
Data.Array.Accelerate.Debug
Data.Array.Accelerate.Error
Data.Array.Accelerate.FullList
Data.Array.Accelerate.Lifetime
Data.Array.Accelerate.Pretty
Data.Array.Accelerate.Product
Data.Array.Accelerate.Smart
Data.Array.Accelerate.Trafo
Data.Array.Accelerate.Type
Other-modules:
Data.Atomic
Data.Array.Accelerate.Array.Lifted
Data.Array.Accelerate.Array.Remote.Nursery
Data.Array.Accelerate.Classes
Data.Array.Accelerate.Classes.Bounded
Data.Array.Accelerate.Classes.Enum
Data.Array.Accelerate.Classes.Eq
Data.Array.Accelerate.Classes.Floating
Data.Array.Accelerate.Classes.Fractional
Data.Array.Accelerate.Classes.FromIntegral
Data.Array.Accelerate.Classes.Integral
Data.Array.Accelerate.Classes.Num
Data.Array.Accelerate.Classes.Ord
Data.Array.Accelerate.Classes.Real
Data.Array.Accelerate.Classes.RealFloat
Data.Array.Accelerate.Classes.RealFrac
Data.Array.Accelerate.Classes.ToFloating
Data.Array.Accelerate.Debug.Flags
Data.Array.Accelerate.Debug.Monitoring
Data.Array.Accelerate.Debug.Stats
Data.Array.Accelerate.Debug.Timed
Data.Array.Accelerate.Debug.Trace
Data.Array.Accelerate.Language
Data.Array.Accelerate.Lift
Data.Array.Accelerate.Prelude
Data.Array.Accelerate.Pretty.Graphviz
Data.Array.Accelerate.Pretty.Graphviz.Monad
Data.Array.Accelerate.Pretty.Graphviz.Type
Data.Array.Accelerate.Pretty.Print
Data.Array.Accelerate.Trafo.Algebra
Data.Array.Accelerate.Trafo.Base
Data.Array.Accelerate.Trafo.Fusion
Data.Array.Accelerate.Trafo.Rewrite
Data.Array.Accelerate.Trafo.Sharing
Data.Array.Accelerate.Trafo.Shrink
Data.Array.Accelerate.Trafo.Simplify
Data.Array.Accelerate.Trafo.Substitution
-- Data.Array.Accelerate.Trafo.Vectorise
c-sources: cbits/atomic.c
if flag(debug) || flag(ekg)
cpp-options: -DACCELERATE_DEBUG
if flag(ekg)
cpp-options: -DACCELERATE_MONITORING
build-depends:
async >= 2.0
, ekg >= 0.1
, ekg-core >= 0.1
, text >= 1.0
, time >= 1.4
if flag(bounds-checks)
cpp-options: -DACCELERATE_BOUNDS_CHECKS
if flag(unsafe-checks)
cpp-options: -DACCELERATE_UNSAFE_CHECKS
if flag(internal-checks)
cpp-options: -DACCELERATE_INTERNAL_CHECKS
if os(windows)
cpp-options: -DWIN32
build-depends: Win32
else
cpp-options: -DUNIX
build-depends: unix
ghc-options: -O2 -Wall -funbox-strict-fields -fno-warn-name-shadowing
ghc-prof-options: -caf-all -auto-all
if impl(ghc >= 7.0)
ghc-options: -fspec-constr-count=25
if impl(ghc == 7.*)
ghc-options: -fcontext-stack=35
if impl(ghc >= 8.0)
ghc-options: -freduction-depth=35
-- Don't add the extensions list here. Instead, place individual LANGUAGE
-- pragmas in the files that require a specific extension. This means the
-- project loads in GHCi, and avoids extension clashes.
--
-- Extensions:
source-repository head
Type: git
Location: git://github.com/AccelerateHS/accelerate.git
source-repository this
Type: git
Tag: 1.0.0.0
Location: git://github.com/AccelerateHS/accelerate.git
-- vim: nospell
