2nd SCIEnce Workshop

Sage: an open-source mathematics software

Sage is a new mathematics software, distributed under the GPL license. Instead of reinventing the wheel, Sage includes several state-of-the-art open-source packages (more than 70 in the current version) with a common Python-based interface (as a consequence, Sage can also be viewed as a bridge between all those packages). The graphical interface uses a web browser, which ensures a high portability of the system. You can download Sage either as a binary for your computer, or as source code and run "make". Several technical tools and scientific actions help to make the Sage community very active, including the interaction with the developers of the upstream packages. The talk will try to give an overview of Sage and some of its features, by means of small examples using Sage.

Parallelizing the LLL Algorithm

SCSCP (Symbolic Computation Software Composability Protocol), and its GAP implementation

Modern symbolic computations increasingly require combination of capabilities available in several different systems. Moreover, there are increasing numbers of symbolic computation resources, such as databases or specialized software which may constitute an interest as Web services. Addressing these two specific needs of the symbolic computation user community, we designed the Symbolic Computation Software Composability Protocol by which a computer algebra system (CAS) may offer services which then may be consumed by a variety of clients, including, e.g. Web server, Grid middleware, local or remote instances of the same or another CAS. The protocol uses OpenMath encoding, extended with two content dictionaries scscp1 and scscp2. To open the afternoon session on SCSCP, I will start with its brief overview, and then present its implementation for the computational algebra system GAP.

An open source C/C++ library for the SCSCP , application to TRIP

We will present an open source C/C++ library for the SCSCP. This framework provides API to develop client applications to access computer algebra systems which support that protocol. Existing computer algebra systems could use this API to provide services to other applications using this protocol. We will give an example of application to the TRIP software.

The state of SCSCP implementation in Maple

This talk presents the current Maple implementation of SCSCP client and server. The client and the core functionalities of the server are written in Maple. MapleNET is used to expose the server as web services. I will give a demonstration consists of usage scenarios of Maple's SCSCP client and server.

Interfacing OpenMath, SCSCP and Java

To open OpenMath and SCSCP a door to a bigger community, it is reasonable to have Java libraries that allow simple and convenient access to these.

In this talk, we will show the state of the Java-libraries org.symcomp.openmath and org.symcomp.scscp, which were developed by the authors and are used within the project for several different needs.

Expressing workflows using Grid enabled Computer Algebra Systems

The half presentation/half demo session aims to introduce a software system that allows Computer Algebra Specialists to express and execute, within the Computer Algebra interface, abstract workflows. The software system automatically generates a concrete workflow and executes it over a Grid infrastructure, developed in the framework of the SymGrid - Services component.

Higher-Order Components (HOCs) | a research project on component-based grid programming in Münster

Computer algebra system in the parallel functional language Eden

This talk summarises the current state of a project on implementing basic computer algebra algorithms in a parallel functional language Eden. The latter is a Haskell extension for distributed memory parallelism, however Eden shows good performance also in a multicore setup.

The talk focuses on two kind of skeletons: one for distributed divide&conquer and other for a more special map&transpose. The examples include different kinds of symbolic multiplication and fast Fourier transform.

Dynamic memory management: challenges and perspectives

Garbage collection (GC) is a key component of almost all modern programming languages. The advent of conventional object-oriented languages supported by managed run-times (e.g. Java, C# and even Managed C++) has brought GC into the mainstream and, as memory manager performance is critical for many large applications, brought GC to the attention of programmers outside its traditional programming language communities.

In this talk, I shall start by reviewing how GC got to where it is today, why it is desirable, what performance you might reasonably expect and I shall outline the directions in which GC research is moving. In particular, I'll look at some of the challenges facing modern GC, from GC for high-performance, multiprocessor systems to better integrating with its operating environment and supporting specific applications.

Following the talk, there will be an opportunity to discuss how GC can better support computer algebra (CA) systems. How are the characteristics of CA workloads (object demographics: sizes, lifetimes, etc)? What requirements should the GC meet (pause time v. throughput, concurrency, etc)? What bottlenecks do they face? Please be prepared to outline your CA system.

SymGrid-Par: Coordinating Parallel Symbolic Computation

In our talk, we will explain the ideas behind, basic motivation, and architecture of SymGrid-Par, a coordination software developed as part of the SCIEnce project. SymGrid-Par is written in the functional language Haskell, and will act as both an SCSCP server and client to coordinate parallel execution of computer algebra systems (running SCSCP servers) for better performance. Parallel programming using functional languages is obviously the tool of choice for mathematical problems, and our talk will introduce parallel skeletons, a concept of high-level parallel programming which captures algorithmic structure declaratively. Furthermore, we describe the global architecture of the SymGrid-Par software system, and give a brief status of the implementation work.

High-level Parallel Programming in Glasgow Parallel Haskell

Glasgow Parallel Haskell (GpH) provides a high-level, annotation-based programming model. This model simplifies the development of parallel applications because most of the issues of controlling the parallel execution are delegated to the runtime-system. However, for tuning the performance of the parallel application, some control of behavioural aspects is desirable. Building on the clean semantics of the underlying computation language, we can use program transformations to optimise the performance of a parallel application.

In this talk I will discuss techniques for improving the performance of parallel GpH programs. In particular, controlling the evaluation order and combining computations to tasks of suitable size significantly improves the performance of the parallel programs. I will demonstrate the software tuning process on several symbolic applications, and compare the resulting performance.

Prescient scheduling of parallel functional programs

CoCoA

Mathemagix

A prototype of KANT SCSCP client shell (Abstract)

The new KANT shell will be written in python. In my demonstration I will show how from the KANT client shell we can connect to the KANT SCSCP server (open through the KANT daemon named kashd). In the next incoming months, the connection to any SCSCP servers must be ok. Using the remote connection, I will do some basic computations by sending some requests written in Openmath to the server and print the answer from the client shell. Note that the answer from the KANT server is written in Openmath (OM) and also, we can convert the simple OM objects (OMI, OMF, OMSTR) back to their python representation and vice versa.