Projects tagged ‘parallel’ and ‘programming’

Haskell is an advanced purely functional programming language. The product of more than twenty years of cutting edge research, it allows rapid development of robust, concise, correct software. With ... [More] strong support for integration with other languages, built-in concurrency, debuggers, profilers, rich libraries and an active community, Haskell makes it easier to produce flexible, maintainable high-quality software. GHC is a state-of-the-art, open source, compiler and interactive environment for Haskell. [Less]

Erlang is a programming language designed at the Ericsson Computer Science Laboratory. Ericsson released the entire source code of the Erlang system including extensive libraries of code for building robust fault-tolerant distributed applications.

DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods. It supports the easy implementation of methods ... [More] like Finite Elements (FE), Finite Volumes (FV), and also Finite Differences (FD). [Less]

Stxxl - Standard Template Library for Extra Large Data Sets. Stxxl is an implementation of the C++ standard template library STL for external memory (out-of-core) computations, containers, and ... [More] algorithms that can process huge volumes of data that only fit on disks. [Less]

What is KorusGetting StartedBackgroundTechnical OverviewWhat can I do with KorusGuidelines and Best PracticesPerformance BenchmarksCommercial UsageShort Term RoadmapContributing To KorusAbout UsWhat ... [More] is KorusKorus is a parallel and distributed programming framework written in core Java. Traditionally such frameworks/platforms are heavy as well as complex in nature. When we started with the concept, one of the things we wanted to have was a very light weight, programmer intuitive and simple model. We also wanted to make sure to have a extremely scalable and very high performance framework in place. Thus we started with this project with an aim to have the best of the simple core Java world and the best of the "conceptual models" in the programming world of Erlang/Haskel/Scala. For more details of the background of Korus please see here. Korus is currently version 1.0.0 Korus is very simple to use , very simple to deploy (one single jar file), and very simple to understand. No need to understand thread programming to use Korus. Korus provides thread-less concurrency by way of code-context-switching. Programmers only write Java functions. In one line Korus is a set of functions calling each other asynchronously and passing messages to each other. Simply break up your problem in a set of functions and code it to the Korus specifications. In the world of Korus these functions are called as "Korus-processes" or simply "processes". One Korus process is one Java function in terms of coding. Korus process is nothing to do with operating system process. They are simply Java functions, but since they behave independent of each other we decided to call them "processes". In all the documentation for Korus, wherever you see the term process, it means a Korus process. Korus is based on Actor Design Pattern. One of first “pure” actor pattern frameworks in Java. For more details of Actor pattern see here. Features Korus basically has two broad category of features. The core set of features which include developing application using Korus processes. Korus-Addons,these include Parallel constructs like parallel_for loop, pipeline etc. Connectivity to Korus from other programming languages. Getting StartedThe best way to start is by having a look at the Getting started page. if you want to have a very quick feel go to the Getting Started Quickly section in guide. It will take only 5 minutes to run the sample program if you have a JDK environment. You can also download the Korus binaries from the download section. It consists of sample programs, Java docs and korus.jar file BackgroundWhile we were debating on the best way to approach this, we realized we already had knowledge of such a "conceptual model". We have been working quite a lot on various upcoming and non traditional programming languages who have their core designed in a way which makes them good candidate for parallel/distributed computing. e.g. Erlang, Scala, Haskel etc. One of the fundamental problems with these languages is that they are very difficult to program and extremely complex in nature. Another major hurdle is the industry acceptability to use these. Though there has been an increase in usage lately, but the overall percentage is very less. Lastly it is very difficult to find expertise in these language, hence a significant barrier to entry. One of the biggest challenges the industry is facing today is achieving Performance, Scalability and Availability. We need to get optimal returns from the hardware we invest in. We need ways to effectively utilize and take advantage of the commodity and multicore available to us. We need a software stack which can make life easier too develop as well as to deploy and run in production. The journey of Korus starts with this background. Technical OverviewFor more details have a look here What can I do with KorusSimply putting it, Korus is very useful if you are planning to write applications which need very high performance & scalability. The application can either be stand alone or distributed or parallel in nature. Additionally, you can use the parallel_for and pipeline constructs to ease development . You can write your own Parallel constructs similar to the parallel_for and pipeline by using the basic Korus API. You can call Korus from other language environments. Guidelines and Best PracticesGuidelines and best practices to use Korus in optimal manner can be found here Performance BenchmarksWe have evaluated Korus in various test scenarios and the results can be found here Commercial UsageKorus is released under GPLv3 and is free to use as per terms of GPLv3. For specific commercial usage of Korus, please contact us at ilabsconsulting@impetus.com Short Term RoadmapHave a maven based build mechanism. Provide out of the box Distributed & Grid based deployment Provide support for connectivity with multiple language environments.Currently only Erlang is supported. Contributing To KorusIf you are interested in contributing to Korus, please contact or send the patches to the project owners. Since we have just started, we are keeping it this way. Once the momentum grows we will be going the complete open source model where anyone can send a patch and the checkins will be moderated. About UsWe are Impetus Labs or iLabs as we call it. iLabs is a R&D consulting division of software product R&D company called as Impetus technologies. (http://www.impetus.com). iLabs focuses on innovations with next generation technologies and creates practice areas and new products around them. iLabs is actively involved working on High Performance computing technologies, ranging from distributed/parallel computing, GPU based software, Hadoop and related technologies. iLabs is also working on various other Open Source initiatives. [Less]

XMDS is a code generator that integrates equations. You write them down in human readable form in a XML file, and it goes away and writes and compiles a C++ program that integrates those equations as ... [More] fast as it can possibly be done in your architecture. [Less]

SwarmA Cellular Programming Language Greg Bramble gmb2106@columbia.edu Thomas Chau tc2165@columbia.edu Jason Gluckman jbg2113@columbia.edu Rajesh Ramakrishnan rr2318@columbia.edu ... [More] AbstractSwarm is a functional dataflow language aimed at building simulations. Its programs are represented by directed graphs of cells. Cells, the basic functional unit, perform computation by responding to particular sets of stimuli and propagate reactions to their neighbors. To achieve a more intricate machine, a programmer must compose primitive cells into more complex ones, which in turn may be composed into yet larger units. MotivationEverything in the world behaves in a cellular manner, participating in vast interactions in which units feel each others‟ influences and emit their own. For example, by universally speaking the language of electromagnetism, atoms compose many interesting molecules. These complexes then compose themselves into larger structures, giving rise to cells. The cells, on the next order of magnitude, act in concert and unite themselves by circulatory networks. Finally, humans, too, interact in a broad social framework and construct organizations to handle mass action. While much reductionist work has been done to probe basic properties of these systems‟ constituents, important applications in biology and social science rely on understanding aggregate behavior in general. Fortunately, the current trends in hardware are beginning to meet the needs of such systems where complexity arises from the synergy of many parallel elements. The days of the single processor are becoming history. They were characterized by programs which were essentially lists of instructions to be processed sequentially. Nearly all high-level languages in existence were written for and conceptually constrained by this paradigm. Even object-oriented programming, whose idea was to group instructions as more distinct entities, is firmly implanted in the original paradigm. While objects maintain their own states, they are nonetheless are filled with functions that must execute and return before the "main" function can continue. The OO paradigm more resembles a guideline for how to organize folders than a break from the procedural style that preceded it. As a consequence, we face a software crisis in which traditional languages have failed to capture parallel computation. We ask ourselves: how can we break away and write code to exploit new multiple processor technology? GoalsThe goal of Swarm is to allow a programmer to explore emergent phenomena conveniently. But even more importantly, Swarm aims to establish a platform on which a programmer can write code that parallelizes naturally. Swarm's style is declarative, capturing the computation in a manner similar to that of functional languages. Its programs, rather than executing operations imperatively, define the juxtaposition of data and functionality explicitly. Swarm is a metalanguage whose operators perform high-level manipulations of the superstructure of a network of functional units. Swarm operators, when executed, link together these functional units, the cells, which provide conventional functionality. [Less]

Parallel programming is widely acknowledged to be more difficult than sequential programming. One reason for this is that parallel programming systems are more difficult to use than their sequential ... [More] counterparts. In particular, few parallel programming systems can support the software engineering requirements of large applications. We intend to assess and compare the usability of a variety of parallel programming systems using a small suite of chained applications called the Cowichan Problems. [Less]

In this project we will build a library of algorithms and data structures and provide a language to build programs on top of the library. The library will be optimized per architecture. This will ... [More] allow the programs written in terms of the library to be intact while benefiting from the speed ups of parallelism under the new architectures. [Less]

One can argue that while the trivial update problem causes trouble in Lisp and its relatives, it does not reflect an inherent weakness of functional programming per se. What is requited for a ... [More] solution is a combination of convenient notation--to access arbitrary elements of a complex structure--and an implementation that is able to determine when the old version of the structure will never be used again, so it can be updated in place instead of being copied. ~ Michael L. Scott, Programming Language Pragmatics S11.2 One final note: both of these models are more easily implemented using a functional programming style. Something as simple as immutable objects makes both local messaging and transactions much simpler and more efficient. It's funny how good practices pay off in ways we don't expect. ~ http://toomuchcode.blogspot.com/2007/04/imaginary-concurrency-debate.html Most functional programming languages are implemented using garbage collection, but while GC is effective for managing memory, it cannot give quick runtime information about usage. Zhe will use reference counting so that where persistence is unnecessary, operations can be implemented destructively. Other proposed features: Not purely functional, for I/O simplicity. Not curried, to allow overloaded functions. No sexpers, because infix and syntax is nice. Full runtime multiple dispatch. OO-reminiscent syntax, without the limitations [Less]