Projects tagged ‘gpu’

The JOGL project hosts the development version of the Java™ Binding for the OpenGL® API (JSR-231), and is designed to provide hardware-supported 3D graphics to applications written in Java. JOGL is ... [More] not the official reference implementation of the JSR, but an evolving workspace; snapshots are taken from this workspace which become the official reference implementations of the JSR. JOGL is part of a suite of open-source technologies initiated by the Game Technology Group at Sun Microsystems. [Less]

Perl module that abstracts OpenGL APIs for use with ARB (assembly), Cg and GLSL shading languages.

Perl module that provides tight integration between OpenGL and various imaging libraries. In the case of ImageMagick, C pointers may be shared between GPU and IM's image cache for optimized performance.

Perl OpenGL Module * Portable * Comparable to C performance * Supports over 50 OpenGL extensions

Brahma is a library written for the .NET platform, to provide high-level access to graphical and general purpose processing on the GPU. It eliminates the need for a shading language, generating shader code directly from IL at runtime.

Moldeo is an open source framework for the development of interactive environments with video, 2D and 3D animation elements in real-time. It is used to create visual environments in theater ... [More] performances, events or any other space where a live visual component is needed. [Less]

CUDPP is the CUDA Data Parallel Primitives Library. CUDPP is a library of data-parallel algorithm primitives such as parallel prefix-sum (”scan”), parallel sort and parallel reduction. Primitives ... [More] such as these are important building blocks for a wide variety of data-parallel algorithms, including sorting, stream compaction, and building data structures such as trees and summed-area tables. CUDPP runs on processors that support CUDA. For detailed information, see the CUDPP Documentation. A good place to start is the simpleCUDPP Example. [Less]

OverviewMotivationThe emergence of GPGPU programming models such as CUDA and OpenCL provide avenues for general purpose application developers to leverage the computation capabilities of highly ... [More] parallel SIMD GPU architectures. PTX defines a machine model and virtual ISA for these architectures that is used commercially by NVIDIA GPUs, but is also representative of other SIMD machine models. Ocelot seeks to develop a set of tools that enable the low level analysis of GPGPU applications as well a providing a JIT compiler for generic architectures. We have completed control and dataflow analysis modules for PTX as well as an emulator for the PTX 1.3-1.4 virtual machine compatible with CUDA 2.1-2.3 applications. We are currently working on a back end binary translator from PTX to various architectures. NewsOctober 30, 2009 : LLVM-Translator validation complete. It passes all SDK and Parboil tests. Video Example September 22, 2009 : Prototype Just-In-Time Compiler from PTX to LLVM finished. Triaging bugs. July 29, 2009 : LLVM Internal Representation finished. July 23, 2009 : Added support for detecting misaligned memory accesses : Release 0.4.72 July 11, 2009 : Added memory checking similar to valgrind : Release 0.4.46 July 9, 2009 : Official Ocelot Release 0.4.36 July 8, 2009 : Ocelot now uses Static Single Assignment as its intermediate representation. June 25, 2009 : Basic dataflow analysis support added. June 22, 2009 : Ocelot has been updated to support PTX 1.4 and CUDA 2.2 . FeaturesCUDA Emulator Ocelot provides an implementation of the CUDA runtime, capable of running the entire CUDA 2.2 and 2.1 SDKs. The above example shows the N-Body example running on Ocelot (left) and CUDA (right). Memory Error CheckingOcelot can detect the following memory errors: Deferencing a host pointer in device code Reading/writing to a memory location that has not been allocated on the device Doing a cudaMemcpy/cudaMemset to an unmapped region or with the wrong flags Doing a misaligned memory access It will gracefully fail and produce useful debugging info: ==Ocelot== Emulator failed to run kernel "_Z4initPi" with exception: ==Ocelot== [PC 9] [thread 29] [cta 3] st.global.s32 [%rd4 + 0], %r3 - Global memory address 0x6d0b70 of size 4 is out of any allocated or mapped range. ==Ocelot== Memory Map: ==Ocelot== Device 0 : Ocelot PTX Emulator ==Ocelot== Nearby Global Variable Allocations ==Ocelot== No Allocations. ==Ocelot== ==Ocelot== Nearby Device Memory Allocations ==Ocelot== [0x6d0970] - [0x6d0b70] (512 bytes) (global) ==Ocelot== ****0x6d0b70**** ==Ocelot== ==Ocelot== At: memoryErrors.cu:6:0Code AnalysisControl Flow Analysis Ocelot provides a full featured parser and internal representation for PTX 1.3 and PTX 1.4. We currently have basic control flow and dominator analysis tools as well. Data Flow Analysis ContributingComplete a Feature RequestIf you would like to contribute to this project and help with any of the directions on our roadmap you can do the following: Pull a task from the list of issues Implement it on your own Post a patch to the relevant issue If it is accepted we will merge it into the main codebase Ask us about becoming a registered developer Branch Our CodeIf you want to work on something not on our roadmap, but want to host your code on this site, contact us about becoming a developer and creating a branch. Start A New ProjectIf you want to work independently using Ocelot as a starting point, feel free to copy our most current release and use it internally. [Less]

GPU ray-tracing is used to create several effect on visualizing three dimensional bitmap information. Dynamic branching and very long shader programs require DX10 capable hardware although project ... [More] itself is based on OpenGL and C++. Editing the data is possible only in per-pixel basis. [Less]

Project Zombie: Project zombie is a game based on the simulation of zombies on the GPU. Graphics will be simple. However, we will strive to make the graphics "interesting looking." With regard to ... [More] the term "interesting looking," an inspiration of ours is the game Darwina. We are not saying our game's graphics will be based on the Darwina look, but rather, we try to achieve the idea presented in Darwina. We believe Darwina has that particular "simplistic but interesting" notion, which we hope to emulate. Another goal of PZ will be the implementation of cellular automaton based effects; we use CA to fake physical based effects, effects that affect the environment, in "interesting" ways. Finally, our ultimate goal is to create an interesting game where the player battles massive hordes of zombie. We hope by injecting massive crowds, we will see emergent based game-play. This is our hope! Hence the reason for this project, to experiment! [Less]