SAC-home.org

Home
-About
-Research
 -Publications
 -Research Team
 -Joining the Team
  -Current Vacancies
  -PhD Projects
  -Smaller Projects
 -Benchmarking SaC
-Documentation
-Download
-Support
-Workshops
-Internal
 

Smaller Projects

There are many possibilities for smaller projects in the context of SaC. As an inspiration, we have listed several ideas for projects below. However, we are interested in all kinds of new ideas! If you have a nice idea for a project or would like to do one of the listed below, please do not hesitate to contact us. Although all the projects can be done purely for the fun of it, they can also serve as a basis / be scaled to suit various academic degrees such as:
  • BSC / final year projects (english)
  • MSC projects (english)
  • 3 month placement / term break projects (english)
  • Studienarbeit (german)
  • Diplomarbeit (german)

Alternative Storage Layouts for High-Performance Computing

this challenge is taken up by : [ Kamala Pitta (2008) ]

The arrival of multi-core processors in the mainstream forebodes a general shift into distributed computing. An effective utilization of such systems requires the software to be used on such systems to consist of chunks of work that can be operated on independently and locally. For large data structures such as arrays a reorganisation of the way the data is stored in memory may have a vast effect on the localality of data and, thus, on the runtime efficiency that can be achieved.

This project investigates the effectiveness of alternative layouts by using the high-performance array language SaC. The intended approach is to re-write several SaC programs in a way that mimicks alternative layouts. Extensive performance comparisons will then give an indication of the effectiveness of the layouts investigated.

Introducing Controlled Forms of Non-Determinism -- Side-Effects within With-Loops

this challenge is taken up by : [ Theo van Klaveren (2006)/ Torben Gerhards (2007)]

The central language for data parallelism in SaC, the With-Loop, is side-effect-free. Although this is essential when it comes to concurrent executions, in some situations, this restriction is rather inconvenient. Examples for such situations include:

  • dbug output within the body of a With-Loop
  • pixel-wise output of computer generated images
  • arrays of random numbers

In all these cases, we are not interested in the exact order the output / side-effect happens. Instead, we want as much concurrency as possible. However, the non-determinism should be confined within With-Loop boundaries.

Optimizing the optimization cycle

Over the years many standard and non-standard optimizations have been integrated into the SaC compiler sac2c. Most of the optimizations benefit from or even rely on the application of other optimizations. As there exist mutual dependencies, the current compiler applies its optimizations by means of several subsequent optimization cycles. However, the dependencies between the individual optimizations have never been fully analysed. Instead the order of their application has been chosen in a rather ad-hoc fashion.

Another problem of the existing optimization cycle is the fact that the optimizations have been developed over a rather long period of time during which some of the side-conditions (such as restrictions on the AST etc) have changed. As a consequence, some of the optimizations rely on assumptions that are only partially true in today's setting, e.g., some well-formedness assumptions do not hold anymore which -- strictly speaking -- may require some extensions of these optimizations.

The challenge of this project is to analyse all optimisations for correctness in the given setting and for relationship to other optimizations. Building up on that information, correctness-issues should be resolved and an attempt to optimize the order of optimization application should be undertaken.

A SaC-frontend for Doxygen

Doxygen (for details see www.doxygen.org ) is a documentation system for programs specified in one of various programming languages. It provides facilities for deriving html documentations from source code without requiring any program modification. However, adding Doxygen-style comments provides a rich set of facilities for enhancing the derived html documents.

While Doxygen is being used in the sac2c compiler project, it cannot yet be used for SaC programs itself. The idea of tis project is to make SaC a possible source language for Doxygen. Due to the syntactical proximity of SaC to C, most likely, the main challenge of this project is to come up with a strip-down parser for SaC function signatures and to integrate it into the doxygen system.

An Eclipse plug-in for SaC

The Eclipse project (for details see www.eclipse.org) provides a multi-platform framework for creating IDEs (Integrated Development Environments). It has been successfully used for many different programming languages. A key to its success is the clear separation between the non-language related core facilities and the language specific parts which are kept in so-called plug-ins. This concept allows new IDEs to be created with rather small programming effort by efficiently making use of the core functionality of Eclipse.

The central idea of the project is to make use of the Eclipse infrastructure to generate an IDE for SaC. A good starting point for doing so is the web-site of Eclipse. It contains several tutorials on how to create new plug-ins for Eclipse.

Visualising Array Programming by Spreadsheets

Array programming as provided by languages such as APL, J, or SaC allows for a high level of abstraction. Most operations of these languages are applicable to arrays of arbitrary rank (number of axes) and arbitrary shape (extends wrt. individual axes). This generality of operators combined with the linearised form of traditional programming style creates difficulties for novice array programmers as not only values of expressions but their shapes as well have to be kept in mind. A graphical programming tool for displaying arrays and for composing simple non-recursive array operations would help overcoming this problem as the shapes and the content of arbitrary intermediate expressions could be visualised.

The idea of this project is to display individual arrays in separate windows in a spreadsheet-style manner. These windows should be linked by means of functional array expressions that define how one window's content is computed from one or several other window's contents. The graphical user interface preferably is created as a Java applet (see java.sun.com for details and tutorials) as this eases portability. While the graphical parts of this tool have to be created from scratch, the underlying array programming machinery can directly make use of one of the existing array programming languages. The compiled array programming language SaC due to its side-effect free core language as well as its C interface seems to be particularly suitable for this task.

A Universal Benchmarking Tool

this challenge is taken up by : [ Maxime Castelein and Julien Viera (2005)/ Daniel Rolls (2008) ]

A prototype has been developed by Maxime and Julien. However, first experiences indicate room for some improvements to make the tool applicable on a larger scale. Dan tries to put these into action.

Benchmarking programs is always a time consuming task, in particular, when comparing programs specified in different programming languages: comparable versions of the same program need to be collected, compilers need to be installed, compiler flags need to be identified, program parameters need to be adjusted to the performance / capabilities of the executing hardware etc.

The situation becomes even more annoying if measurements need to be redone on a slightly different platform as it usualy requires all ad-hoc mechanisms for measuring, such as makefiles or scripts, to be adjusted.

The core idea of this project is to develop an automated benchmarking system which keeps all relevant measurement parameters in a database and automatically deploys measurements whenever a new benchmark or executing platform is added.

SaC Server Pages

The idea of embedding programming languages in html is not new. For the java programming language there exist java server pages and even for Pascal pascal server pages have been developed. The aim of this project is to do the same for the SaC programming language. It is meant as an introduction into compiler construction and thus especially suitable for term break projects.

The project can be split into two orthogonal tasks:

  • developing a ssp (SaC Server Pages) to sac compiler
  • developing the SaC runtime support to allow for cgi programming in SaC

For the former, the implementation language can be freely chosen as long as it is portable among different platforms. The latter task has obviously to be implemented in SaC.

SaC Web Services

This project aims at bridging web service technology and the SaC programming language. The idea is to create a flexible framework that allows to input and process data gathered from web services and to write methods for web services in SaC. The project includes:

  • designing SOAP representations for SaC datatypes and implementing the necessary runtime support
  • developing a tool to generate SaC stubs from wsdl service descriptions

A Database Interface for SaC

Array visualisation in SaC

The array visualisation projects offers a wide range of possibilities. It can be anything from generating X3D to smart text output, from using OpenGL to using plotting libraries like DISLIN. The only constraint is your imagination and

  • the ability to visualise arrays
  • a smooth integration into SaC
  • a portable implementation

Data Mining in SaC



Responsible for the content of this site: SAC-Research Team.
Last modified: 18. Apr 2013

Valid HTML 4.01!     Valid CSS!