We all look for people who know how to code GPUs. Experience is key, so you need to have at least one year of experience in GPU-programming.

Submit your CV now and don’t give up on your dream leaving behind the boring times.

StreamComputing

Amsterdam-based StreamComputing is a young startup with a typical Dutch, open atmosphere (gezellig). Projects are always different from the previous as we work in various fields. Most work is in parallisation and OpenCL-coding. We are quite demanding of your knowledge on the various hardware-platforms OpenCL works on (GPUs, mobile GPUs, array-processors, DSPs, FPGAs).

See the jobs-page for more information and how to apply.

Appilo

North Israel based Appilo is seeking GPU-programmers for project-basis contracts. Depending on the project, most of the work could usually be performed remotely.

Use the mail on the contact-page at Appilo to send your CV.

AccelerEyes

Atlanta-based AccelerEyes delivers products which are used to accelerate C, C++, and Fortran codes on CUDA GPUs and OpenCL devices. They look for people who believe in their products and want to help make them better.

See their jobs-page for more information and how to apply.

The post GPU-developers, work for StreamComputing and friends appeared first on StreamComputing.

The winner of this year used OpenCL to compute real-time procedurally generated geometries. For the rest C++, OpenGL and Gamemonkey Script was used.

Tech features: curl noise, volumetric textures, Perlin noise, mesh deformations, HDR/bloom, film grain, fractals, Hermite splines, Tweens and quaternion iridescent particles.

The creator, Tokyo-based Eddie Lee, has done more projects – be sure to visit his homepage. I hope more demosceners start using the power of OpenCL to get more out of their demo’s.

Do you see where below kernel is used? Hint: check the other videos of Eddie.

__kernel void curlnel( 
                      __read_only image3d_t volume,  
                      sampler_t volumeSampler,  
                      __global float4 *output,  
                      float speed 
                      ) 
{ 
    uint index = get_global_id(0); 
    uint numParticles = get_global_size(0); 
    float indexNormalized = (float)index/numParticles; 

    // read from 3D texture 
    float4 vertData = output[index]; 

    float3 samplePos = vertData.s012; 
    samplePos = samplePos+(float3)(0.5f); 

    float4 voxel = (read_imagef(volume, volumeSampler, 
                   (float4)(samplePos,1.0f))); 

    vertData.s012 += voxel.xyz*speed; 

    output[index] = vertData; 
}

According to GPUVerify (see previous post) the line starting with “float4 voxel” has an error.

The post Winning demo of Tokyo Demo Fest 2013 uses OpenCL appeared first on StreamComputing.

Below you find a online version of the tool (please don’t break it!). Play around and test your kernels. Currently it is limited to OpenCL-kernels. Be aware the number of groups is different from global worksize.

For demo-purposes some values have been pre-filled with a simple kernel – press “Check my OpenCL kernel” to find the results. Did you expect this from this kernel? Can you explain the result?

After the LEAP-conference I’ll extend this article – till then I’m too time-limited. For now I wanted to share the online version with you, especially with the people who will attend the tutorial at LEAP. Be sure to check out the GPUVerify website and paper to learn more about this fantastic tool!

The post Verify your OpenCL kernel online appeared first on StreamComputing.

A separate ticket for only the first day can be bought, as then will be a crash-course into OpenCL. Module basics.

The second and third day will all about parallel-algorithm design, optimisation and error-handling. Module optimisation with several new subjects added.

The afternoon of the third day is reserved for special subjects, as requested by the attendees.

If you are at LEAP, wait for the promotional code you get there.

More detailed information is coming soon.

The post 21-23 August: OpenCL Training London appeared first on StreamComputing.

Little Britain: “Compu’er says no”. (links to Youtube movie)

Knowing all errors by heart is good for quick programming, but not always the best option. Therefore I started to create a full list with extra info, taken from cl.h and the reference documentation.

The problem with many error-codes is that they are sometimes context-dependent and then become quite useless in helping the programmer out. Also some drivers return different error-codes. Notice also that different errors are given per OpenCL-version for the same function. If you find problems, help make OpenCL better and give feedback.

Want it on your wall? You can easily copy these two tables into Excel or alike software and print it out.

Run-time and JIT Compiler Errors (driver-dependent)

The last four (-16 till -19) are new in OpenCL 1.2.

Compile-time Errors (driver-independent)

The last four (-65 till -68) are new in OpenCL 1.2.

Hope you find this useful! Let me know how I could improve this list!

Have this in code-form? Supply a link in comments.

The post OpenCL 1.2 error codes appeared first on StreamComputing.

Young entrepreneurs and academics with a great product/project are invited to present their solution. As the event draws around 2000 people, you get the attention needed to show-case your new company or research-group. Your solution does not need to be based on FPGAs or GPUs, as long as Von Neumann’s architecture is not in it.

Read the information below or directly go to the ERSA-NVIDIA awards-homepage.
“Von Neumann’s architecture lasted for 75 years.”
That genius can no longer lead us into the new age of computing that is upon us. This competition seeks to acknowledge those pioneers that are helping to build the new computing landscape”

Submission of Proposals for ERSA-NVIDIA award Candidates
Deadline: May 6, 2013
Send proposals to org@ersaconf.org

The Award is devoted for entrepreneurs developing tools, advanced technologies and opportunities for supporting applications, both academic and commercial, across broad area of high-performance, embedded systems implemented as multicore systems and reconfigurable heterogeneous parallel processing systems.

The Award Committee includes:

Leading Universities

•  Stanford University, USA, Prof. Michael Flynn
•  Imperial College London, UK, Prof. Wayne Luk
• Karlsruhe Institute of Technology, Germany, Prof. Joerg Henkel
• Keio University, Japan, Prof. Hideharu Amano
• Shanghai Jiao Tong University, China, Prof. Simon See

Leading Companies (tentative list):

• NVIDIA, Can Ozdoruk, Product Manager
• Altera, Steve Casselmanm, Principal Engineer
• National Instruments, Hugo Andrade, Principal Architect

For more info go to: http://ersaconf.org/awards/

If you have any question, just ask them in the comments or send us an email.

The post ERSA-NVIDIA award for “Best Young Entrepreneur” appeared first on StreamComputing.

A separate ticket for only the first day can be bought, as then will be a crash-course into OpenCL. Module basics.

The second and third day will all about parallel-algorithm design, optimisation and error-handling. Module optimisation with several new subjects added.

The last part of the third day is reserved for special subjects, as requested by the attendees.

More detailed information is coming soon.

The post 3-5 June: OpenCL Training Amsterdam appeared first on StreamComputing.

OpenCL on ARM: Growth-expectation of GFLOPS/Watt of mobile GPUs exceeds Moore’s law. That’s incredible!

Jan Gray: .@OpenCLonARM GFLOPS/W more a factor of almost-over Dennard Scaling. But plenty of waste still to quash. http://www.fpgacpu.org/papers/Gray_AutumnOfMooresLaw_SingularityUniversity_11-06-23.pdf …

Jan Gray‏: .@openclonarm Scratch Dennard tweet: reduced capacitance of yet smaller devices shd improve GFLOPS/W even as we approach end of Vdd scaling.

David Kanter: @jangray @OpenCLonARM I think some companies would argue Vdd scaling isn’t dead…

Jan Gray: @TheKanter @openclonarm it’s not dead, but slowing, we’ve gone from 5V to 1V (25x power savings) and have maybe several hundred mVs to go.

David Kanter: @jangray I reckon we have at least 400mV, so ~2X; slower than ideal, but still significant

Jan Gray: @TheKanter We agree, I think.

David Kanter: @jangray I suspect that if GPU scaling > Moore’s Law then they are just spending more area or power; like discrete GPUs in the last decade

David Kanter: @jangray also, most positive comment I’ve heard from industry folks on mobile GPU software and drivers is “catastrophically terrible”

Jan Gray: @TheKanter Many ways to reduce power, soup to nuts. For ex HMC DRAM on interposer for lower energy signaling. I’m sure many tricks to come.

In a nutshell all the reasons they think mobile GPUs can outpace Moore’s law while staying under a certain power-usage.

It needs some background-info, so let’s start the background of the first tweet, and then explain what has been said.

More than Moore for mobile GPUs

Requirements for Mobile GPUs were not really high until the iPhone and Android came along. Of course there was demand, but not from such a big market. This caused a big push forward of mobile GPUs. The reason it can grow faster than other processors is because there is catching up possible – at least that is what I picked up in general terms.

For example Imagination Technologies promises a lot with PowerVR series 6: “With a growing range of cores optimised for either area (maximising GFLOPS/mm2) or performance (maximising GFLOPS/mW), PowerVR Series6 GPUs can deliver 20x or more of the performance of current generation GPU cores targeting comparable markets. This is enabled by an architecture that is around 5x more efficient than previous generations. PowerVR Series6 GPU cores are designed to offer computing performance exceeding 100GFLOPS (gigaFLOPS) and reaching the TFLOPS (teraFLOPS) range enabling high-level graphics performance from mobile through to high-end compute and graphics solutions”. Currently they are around 70 GFLOPS and 1 TFLOPS should be reached before 2020 when they have the same pace in advancements as desktop GPUs. But they claim the reach it with Series 6!

What do Jan and David have to say about it?

Dennard’s scaling

Jan takes back this reason a tweet later, but it’s an interesting rule anyway:

The post Scaling mobile GPUs to 1000 GFLOPS appeared first on StreamComputing.

Another way to look at technologies like WebCL, is that it makes it possible to lift the standard base from the OS to the browser. If you remember the trial of Microsoft’s integration of Internet Explorer, the focus was on the OS needing the browser for working well. Now it is the other way around, but it can be any OS. This is because the push doesn’t come from below, but from above.

Last year two guys from Lyon (South-France) got quite some attention, as they wrote a WebCL-plugin. Their names: Adrien Plagnol and Frédéric Langlade-Bellone. Below you’ll find a Q&A with them on WebCL. Enjoy!

Adrien Plagnol

I’m 25 and I live in Lyon, France, I’m currently employed as a Java engineer in a big IT company. I got involved in the Google Summer of Code in 2012 during which I worked on integrating WebCL in Firefox’s core. I am now following the latest advances on the project as a spectator as my current occupation is quite time consuming !  (photo on the left)

Frédéric Langlade-Bellone

I did my bachelor degree in Montpellier then I moved to Lyon where I was granted my Master’s degree in computer graphics at the end of last year. I now work in the same company as Adrien, as a GIS (Geographic Information System) engineer. I discovered WebGL and WebCL during my studies, during which I worked on an online 3D GIS-data viewer and on some WebCL demos, with the help of Fabien Cellier, the PhD student who is working on WebCL and who was supervising me. Nowadays, I do work on some WebCL projects at a slow-paced rhythm. (photo on the right)

The Q&A

WebCL introduction

Vincent Hindriksen (VH): Could you describe what WebCL actually is ?

Adrien Plagnol (AP): WebCL is a binding of the desktop OpenCL library, but in a Javascript-fashioned way. It is really close to the C++ wrapper in that it is object oriented. It is able to manage standard Javascript types, including TypedArray (which were introduced for WebGL) and DOM events. As the desktop version includes OpenGL interactions, WebCL is also able to use WebGL buffers, even if this feature is described as optional in the specs.

Frédéric Langlade-Bellone (FLB): We were both introduced to OpenCL and WebCL by Fabien Cellier, which was one of the early developers of WebCL and who is now part of the Khronos Group that standardize WebCL as a non-voting member.

–

VH: There is not one project, but many. And they are not compatible. In the beginning it was Nokia’s implementation which got a lot towards “the standard”, but Khronos initiated a standardisation of WebCL. Could you tell something about the standardisation and your view on it?

FLB: The standardization already had good effects on the Samsung implementation of WebCL, as in the beginning it was working but the API was mainly a litteral conversion of the C API that did not take into account specificities of JavaScript.

The new version is based on the current draft of Khronos WebCL and is way easier to use in a JS environment. Moreover, even if Nokia’s implementation is quite easy to setup, it does not have CL/GL interaction. This interaction is quite useful as it allows you to use the same buffers for WebCL and WebGL, saving simplicity of code and global running speed. The standard will allow the developer to know whether the current implementation has CL/GL interaction, independently of a specific implementation. Nowadays, the three know implementations (Nokia, Mozilla and Samsung) are evolving to get the same API, which for me is the first step of WebCL becoming available for everyone.

[VH: see also https://github.com/ParapluieDotOrg/CommonWebCL by Frédéric for an effort to unite the various flavours]

–

VH: What is the current state of WebCL?

AP: WebCL is currently being worked on at Khronos and a public working draft is available at https://cvs.khronos.org/svn/repos/registry/trunk/public/webcl/spec/latest/index.html. Chrome, Safari and Firefox already have an available WebCL implementation, but the API is different for each one.

–

VH: In what way could you compare WebCL to its older brother WebGL? Will WebCL walk the same route?

FLB: I think it will be way harder for WebCL to become as spread as WebGL. Our days everyone can understand why we need OpenGL in our browsers, mainly because it’s visual. But OpenCL is not visual, and it needs more work to be understood, so I don’t think the WebCL community can be as big as the WebGL community, and that means that its integration in web browsers won’t be set as a priority in the years to come.

Demo Time

VH: Could you show off a demo made by you?

AP: I made an opensource bitcoin miner based on the WebCL Firefox API. It is available on Bitbucket : https://bitbucket.org/dalsh/jsoclbm (live demo is available at http://jsoclbm.parapluie.org/ for the few people who has a WebCL-enabled Firefox)

FLB: I made a demo based on simple physics interactions between particles and basic objects. You can watch it here :

https://www.youtube.com/watch?v=tdqBUCvxd4w&feature=g-upl

It is just meant to be an example of what can be done using WebCL, but it is not at all a technical demonstration. The idea is just to show that WebCL development is quite easy. Source code is available at https://github.com/ParapluieDotOrg/PartyingParticles.

–

VH: What is your favourite demo made by others?

FLB: It’s the GPU-based image editor made by Nokia. Actually, I haven’t played with it for a long time, but to me it is one of the best example of what WebCL could be used for.

Application Areas

Liad Weinberger (LB): Will WebCL be used for more than games and Bitcoins?

AP: WebCL may prove useful for image processing, distributed computing ( like the *@home projects ), etc… For every OpenCL usage we can imagine a WebCL equivalent in a web browser, providing lightweight client advantages and in some cases social interactions (ie. community based image editing, video/audio encoding… ).

Security

VH: What would be the potential dangers of the web due to WebGl and WebCL? Stealing of processor-time is much more doable than with just JavaScript.

FLB: I do know that people are working on the security issues for WebCL, correcting some issues related to privacy but also on the way WebCL will use your processor. Something more reliable than the Windows watchdog, which considers the GPU has crashed when it does not respond for more than two seconds. Moreover, we can imagine asking the user the permission to execute a processor-intensive process, in the same way that it is done for geolocalization.

–

VH: A possible side-effect. Can WebCL/GL be used to determine the hardware has, without user-interaction? And if so, is this handy for game-developers and computer-shops to propose compatible games and computer-upgrades?

AP: We never really thought about that kind of use but it is true that OpenCL is able to provide hardware discovery features which would be built-in the browser. This would allow a game company to inform the user if its GPU (at least) is powerful enough to run a game directly from the browser without installing any plugins or needing IT knowledge.

FLB: Moreover it could also allow a company to get statistics about hardware configurations of potential game customers, which would help them into optimizing games to the most common configurations.

The OpenCL problems

VH: OpenCL gets much more standardised into libraries and reachable in higher level code. Will WebCL do the same? And if so, how do you see these libraries and higher level programming concepts will get into WebCL?

FLB: I can easily imagine a library that would provide some common algorithms with multiple implementations (WebCL, WebGL using framebuffers, JS), choosing the most powerful one depending on the user hardware : JavaScript is a great langage when it comes to this kind of abstraction For libraries concerning WebCL itself, it would certainly need libraries to provide frequently used routines in the CL language. We can think of a core library, that just provide a way to load third-party CL functions into an already existing CL program. Other libraries would just have to plug onto this library to provide new functions. However, apart from these points, WebCL won’t need a lot of specific library, as the idea for me is that WebCL integration should be done in most already existing Javascript library : I can’t wait to see WebCL in bullet.js, for instance.

–

VH: A little bit technical. OpenCL is not performance portable. What techniques do you use in WebCL to offer best performance per device? Multi-kernel?

FLB: Yes multiple kernels is for me the simpliest way to get it working. That’s another issue that should be resolved by libraries – seamlessly detecting what can be done using the current device and giving reliable data to know if the program we would like to run won’t be too intensive for this device. Indeed it is quite easy to write the different kernels, but the difficult part is the detection of which one should be running. Running a small benchmark at the beginning is a useful marker but I don’t think it should be the only one as it is related to the current state of the computer (powersaving etc…) but it could also use device informations provided by WebCL.

WebCL could also prove useful in optimizing 3d models on the go based on customer hardware capabilities : performance detection could prove handy in that case.

The future

VH: IE is not the dominant browser anymore, and does not hold back web-innovation as it did for many years. As they did not implement WebGL (yet), what do you think about the influence of IE if it comes to acceptation to WebCL as the GPGPU-standard in the browser?

FLB: I’m quite pessimistic on that one. Officially, Microsoft does not want WebGL because of security issues (reading GL buffers filled by a previous website for instance). WebCL has the same issues, and even if most of them can be resolved at middle-term, they will end up finding a new way of rejecting OpenGL and OpenCL based technologies. We should not forget that IE is still used by 1/2 worldwide visitors and I really hope that Microsoft will provide at least alternatives based on DirectX or DirectCompute allowing us to go further with GPU based technologies instead of being always limited by the poor IE support for those.

–

VH: say its the end of Q4 2013 – WebGL and WebCL are in all browsers. How do you think the internet looks like? How would my experience on Wikipedia be? (a broad question, but please answer it in a positive way)

AP: It won’t change so much on Wikipedia, except that it might prove useful for live examples ( ie. physic models ). But in a more general way, it will open many new horizons. For instance, high-grade browser games could become a reality. Moreover, this open the doors to smaller projects aiming at a wide audience and using WebCL in a creative manner ( for promotional purpose for instance, as Disney did using WebGL for the Oz movie interactive promotion ).

FLB: It will also spread the idea that even complex applications can be easily shared as we won’t need to go through an installation process. One can imagine creating a very specific app and sharing it in the same day with his community, without having to care about specific OSes or platforms.

Try out WebCL yourself

Start with an introduction on http://www.ibiblio.org/e-notes/webcl/webcl.htm to install WebCL on Firefox. There you’ll find some demo’s, but also on http://webcl.nokiaresearch.com/demos.html

Add your favourite demo in the comments, for others to see. Got questions? Just ask.

Like to hear more of what these guys are doing? Follow them on twitter: @adrienplagnol – @fredericlb

The post Q&A with Adrien Plagnol and Frédéric Langlade-Bellone on WebCL appeared first on StreamComputing.

Building bridges in a new industry

Embedded processors always have had the focus on low-energy. Now a combination of Moore’s law, the frequency-wall and multi-processor developments have made it possible for these processors to compete in completely new market segments. Most notable due to impressive advancements in graphics IP.
We are now looking at four groups who are interested in learning from each other:

• The embedded processor market
• The FPGA market
• The HPC and server market
• The GPGPU market

And answer the question: how can we get more out of low-energy processors by looking at other industries?

The goal of the LEAP conference is to bring these three groups together. Creating the windows to each other and paving roads over the newly constructed bridges. This makes it one of its kind. Half of the conference is focused on quality information sharing and the other half on networking. For more information, check the website of the LEAP-conference. StreamComputing is a co-organiser.

Call for papers is now open! Programme is filled!

Promotional video

Papers

We’d like to focus on this new space, as there is so much to learn from each other. A few examples:

• You are in the group of HPC and have looked into low-energy computing.
• You are into GPGPU and have tried GPU-computing on ARM.
• You have new insights on FPGA vs GPU, or combined it in reconfigurable GPUs.
• You see your paper fit in the below Venn-diagram, Mobile GPUs and ARM64 just being two examples.

Examples of submission topics:

• Applications: Computer Vision, Image & Video Processing, Crytography, and more…
• Hardware: The lastest ARM, Mobile GPU, Low-power x86 and FPGA
• Software development: OpenCL, C++ AMP, OpenMP, RenderScript, etc.
• Devices: Mobile phones, tablets, low-power embedded, HPC and server environments
• Tips and Techniques for writing portable applications

For information can be found on the call-for-papers page on the webpage of the LEAP-conference.

If you think your work is of interest for the conference, we’d kindly ask you to send an abstract. If you have any question, just ask.

The post LEAP-conference call for papers appeared first on StreamComputing.