www.martinpeniak.com

La Playa

martin.peniak@plymouth.ac.uk (Martin Peniak) — Mon, 22 Apr 2013 11:44:58 +0000

[youtube:http://www.youtube.com/watch?v=q-fZi4je3IY 660 500]

Amazers.org - aspire to inspire

martin.peniak@plymouth.ac.uk (Martin Peniak) — Sat, 09 Mar 2013 13:25:20 +0000

There are times where each of looks for a little bit of extra motivation. I personally love reading short and inspirational quotes that brighten up my day, divert my attention on things that matter and make me feel that anything is achievable when big dreams meet perseverant action. I believe that people are potentially powerful beyond imagination. I say potentially because everyone can do amazing things taking our breath away but not everyone does. However, what matters is that everyone can.

“Whether you think you can, or you think you can't--you're right.”

The quote above by Henry Ford sums it all up, however, how can one really develop this conviction that our dreams are achievable? There are people, ordinary individuals who have strong passion for what they do and who came a long way in achieving their vision. I am sure that if you asked them how they managed this, they would tell you different stories and answers but you would definitely start noticing a common overlap among them, which you can then use for your benefit.

Would not it be great if there was one place where we could go to get inspired? A place that would let you browse through stories of ordinary people who believed and achieved their dreams. How did these people manage to do it and where did they get their inspiration from? What do they think are the main qualities that help us succeed and make a difference?

Well, there is soon going to be such place that will provide all these answers. I came across an amazing idea by Danilo Salvatore Carlucci who is determined to inspire and empower people world-wide. Danilo and his friends have developed an on-line interactive website that shares stories of amazing people, their unique views and passions. I am very excited about this project and I am sure it is going to be a great success. The website is going to be opened in the coming weeks. If you like the idea you can visit Amazers.org and enter your email address. Once the website is ready, you will get an email notification and will be able to start exploring and getting inspired! :)

Aquila 2.0 - Software Architecture for Cognitive Robotics

martin.peniak@plymouth.ac.uk (Martin Peniak) — Fri, 22 Feb 2013 18:57:34 +0000

I am extremely excited to announce that the new Aquila 2.0 has been released. This release is by far the most significant one in the history of Aquila project.

Let me rewind the clock three years ago when the very first Aquila was born. At this time, Aquila was merely my own little GUI (Graphical User Interface) application that was helping me with my PhD research. Aquila was made to simplify the work with the iCub humanoid robot, back then, the latest addition in our laboratory. At this time, I have just finished collaborating with European Space Agency (ESA) and one of my friends, who knew about the work with ESA, sent me a paper about accelerating neural networks with Graphics Processing Units (GPU) showing impressive speedups over CPU implementation. This was mainly because neural networks are inherently parallel and thus better suited for parallel GPU processors. The whole idea of using GPUs in all my future research was very exciting and I started looking into it more and more, which resulted in Aquila adopting NVIDIA CUDA parallel computing architecture. From this point on, everything that was implemented in Aquila could use CPUs as well as GPUs. If a user did not have an NVIDIA GPU device installed on his/her system then a CPU mode would still work although usually significantly slower.

Over the time, I developed new modules such as Self-organising maps (SOM), Multiple time-scales recurrent neural networks (MTRNN), Sequence Recorder, Vision, Simulator and others. My colleague Anthony Morse have later joined Aquila project and started developing new modules too, for example, Echo state networks (ESN), Modi and Epigenetic robotic architecture (ERA). Not to forget Chris Larcombe, who developed the Abstraction-reaction-accumulator (ARA) module inspired by early cybernetics research.

Aquila was growing in size and was becoming increasingly used by our team, students as well as other researchers in different countries, e.g. USA, Italy, Germany, Turkey. Aquila made things easier, however, not everything was as good as it sounds. There were major problems on the horizon such as:

Aquila could only run on Linux
Due to increasing number of modules and their dependencies, the compilation and installation process became rather long and quite challenging for non-technical users
Aquila modules could not be used individually and could not be used without their graphical user interfaces, this made the whole design non-modular and non-scalable
Some of Aquila's modules, e.g. Vision were quite unstable

I am deliberately skipping a lot of design changes in the previous Aquila 1.x versions, however, it is worth to note that we attempted to address the above issues the easier way but never really succeeded until now. We realised that if we want to keep the Aquila project alive and growing, we need to make fundamental design changes, which we proposed almost exactly a year ago in this post and in this webminar, which Tony and myself presented while I worked at NVIDIA research in Santa Clara, California. The new design needed to address all of the above issues and I am glad to say that it did. The new design is very simply and I believe that it is very elegant too!

Aquila 2.0 is now able to run on Linux, OSX and Windows and its dependencies are only Qt (graphical user interfaces), YARP (communication over network) and CUDA (GPU-accelerated code). Aquila modules are compiled separately from Aquila. These so-called Aquila modules can run anywhere on the network in any number of instances and on any available NVIDIA GPU devices. All these modules can be easily managed and visualised via Aquila, which apart from many other features also provides graphical user interfaces for the modules. Aquila modules can be used either from the terminal (just as any other module from iCub repository) or via Aquila with an additional advantage of module management and visualisation features, which were very desired. Aquila modules can spawn other modules and use their functionalists.

Aquila 2.0 was designed to be not just very easy to use but also easy to develop for. Aquila 2.0 provides many different visualisation tools, modules and libraries that can be simply reused. For example, Module Generator tool lets a user to generate his/her own heterogeneous CPU-GPU module together with its graphical user interface. This is all done by one click of a button. After this, the only thing that a developer needs to do is to write his/her functions and add connections between them to their interfaces. Have a look at the video below, which is not very exciting on its own but it shows that it literary takes less than a minute to download, compile, install and Aquila and also to create a new module. All done within a minute!!!

[youtube:http://www.youtube.com/watch?v=koRlPh_arRU 660 500]

The following are some of the main benefits of developing in Aquila software architecture:

Performance - distributed module running heterogeneous CPU-GPU code are able to take a great advantage of available resources.
Integrability - existing modules and GUIs can be easily integrated to form new modules of higher complexities.
Modularity - module GUIs and modules are completely independent. Modules are fully functional with or without GUIs.
Scalability - modules can run on Linux, OSX or Windows across any number of computers and using any number of GPU devices available. The Aquila architecture makes it easier to develop modules that use are able to scale-up with increasing computational demands. For example, ERA module is able to spawn multiple SOMs on multiple computers dynamically based on its needs.
Usability - intuitive, easy-to-use, dynamic graphical user interfaces loosely coupled with modules. Support - we are happy to provide free technical support to promote the research in cognitive robotics and heterogeneous CPU-GPU computing.
Support - we are happy to provide free technical support to promote the research in cognitive robotics and heterogeneous CPU-GPU computing.

Visit Aquila project page

Visit Aquila Facebook fanpage

Download technical paper

Download Aquila 2.0

Spotlight in Connect magazine

martin.peniak@plymouth.ac.uk (Martin Peniak) — Sat, 22 Dec 2012 11:13:11 +0000

Half a million visitors

martin.peniak@plymouth.ac.uk (Martin Peniak) — Sat, 22 Dec 2012 11:07:49 +0000

Thank you all for coming over and keeping eye on this site that reached half a million visitors today :)

Cute robot-shopping video by Plymouth University

martin.peniak@plymouth.ac.uk (Martin Peniak) — Fri, 16 Nov 2012 09:14:00 +0000

If you like the video then check their Facebook pages our. One is Plymouth University Robot Football and the other one you might like is BotSpotTV.
[youtube: http://www.youtube.com/watch?v=01J9D1oJ09Q 660 500]

New CUDA Teaching Center

martin.peniak@plymouth.ac.uk (Martin Peniak) — Tue, 13 Nov 2012 14:31:24 +0000

It has been few years since I started looking into CUDA as a way of speeding up my software. At the beginning I was impressed with the reported speedups of neural network processing, which was the main impetus for the development of GPU-accelerated Aquila software for cognitive robotics. Anthony Morse and myself did several presentations at our university and at that time CUDA was not as well-known as it is nowadays. We could clearly see the benefits of using GPUs for the sort of computations we were doing but convincing others was a little bit of a challenge back then. Later on we would set-up a new GPU cluster and started using it for the training of our humanoid robot iCub,

One day I posted a video of this training to NVIDIA Facebook page, which led to a series of events including the establishment of the new NVIDIA CUDA Teaching Center at our university. Davide Marocco and myself started a new parallel computing module (SOFT339) and as a dedicated CUDA prophet (name given by my supervisor) I am really happy to be given the opportunity to teach CUDA, reach and inspire the new generation of parallel programmers and make a difference. The students seem to be enjoying the module and I am trying to keep the material both useful and interesting.

We are definitely not stopping here, our goals are high and we plan to reach more students and companies in the very near future so stay tuned :)

CUDA by numbers

martin.peniak@plymouth.ac.uk (Martin Peniak) — Mon, 12 Nov 2012 23:33:57 +0000

Updated biography section

martin.peniak@plymouth.ac.uk (Martin Peniak) — Tue, 16 Oct 2012 12:37:01 +0000

The Bio section was just updated with a new article written by Andrew Merrington.

CUDA Thread Indexing Cheatsheet

martin.peniak@plymouth.ac.uk (Martin Peniak) — Sat, 06 Oct 2012 19:44:10 +0000

If you are a CUDA parallel programmer but sometimes you cannot wrap your head around thread indexing just like me then you are at the right place.

Many problems are naturally described in a flat, linear style mimicking our mental model of C’s memory layout. However, other tasks, especially those encountered in the computational sciences, are naturally embedded in two or three dimensions. For example, image processing tasks typically impose a regular 2D raster over the problem domain while computational fluid dynamics might be most naturally expressed by partitioning a volume over 3D grid.

NVIDIA CUDA Thread Model

Sometimes it can be a bit tricky to figure out the global (unique) thread index, especially if you are working with multi-dimensional grids of multi-dimensional blocks of threads. I could not really find a simple cheat-sheet that would demonstrate what exactly you need to do to calculate a global thread index for every configuration you might need to use. I know that with a little effort anyone can figure it out but I thought I would share some of my code with you to make your life easier. At the end of the day, sharing is caring :)

Download example code, which you can compile with nvcc simpleIndexing.cu -o simpleIndexing -arch=sm_20

1D grid of 1D blocks

device int getGlobalIdx_1D_1D()
{
return blockIdx.x *blockDim.x + threadIdx.x;
}

1D grid of 2D blocks

device int getGlobalIdx_1D_2D()
{
return blockIdx.x * blockDim.x * blockDim.y + threadIdx.y * blockDim.x + threadIdx.x;
}

1D grid of 3D blocks

device int getGlobalIdx_1D_3D()
{
return blockIdx.x * blockDim.x * blockDim.y * blockDim.z
+ threadIdx.z * blockDim.y * blockDim.x + threadIdx.y * blockDim.x + threadIdx.x;
}

2D grid of 1D blocks

device int getGlobalIdx_2D_1D()
{
int blockId = blockIdx.y * gridDim.x + blockIdx.x;
int threadId = blockId * blockDim.x + threadIdx.x;
return threadId;
}

2D grid of 2D blocks

device int getGlobalIdx_2D_2D()
{
int blockId = blockIdx.x + blockIdx.y * gridDim.x;
int threadId = blockId * (blockDim.x * blockDim.y) + (threadIdx.y * blockDim.x) + threadIdx.x;
return threadId;
}

2D grid of 3D blocks

device int getGlobalIdx_2D_3D()
{
int blockId = blockIdx.x
+ blockIdx.y * gridDim.x;
int threadId = blockId * (blockDim.x * blockDim.y * blockDim.z)
   + (threadIdx.z * (blockDim.x * blockDim.y))
   + (threadIdx.y * blockDim.x)
   + threadIdx.x;
return threadId;
}

3D grid of 1D blocks

device int getGlobalIdx_3D_1D()
{
int blockId = blockIdx.x
+ blockIdx.y * gridDim.x
+ gridDim.x * gridDim.y * blockIdx.z;
int threadId = blockId * blockDim.x + threadIdx.x;
return threadId;
}

3D grid of 2D blocks

device int getGlobalIdx_3D_2D()
{
int blockId = blockIdx.x
+ blockIdx.y * gridDim.x
+ gridDim.x * gridDim.y * blockIdx.z;
int threadId = blockId * (blockDim.x * blockDim.y)
+ (threadIdx.y * blockDim.x)
+ threadIdx.x;
return threadId;
}

3D grid of 3D blocks

device int getGlobalIdx_3D_3D()
{
int blockId = blockIdx.x
+ blockIdx.y * gridDim.x
+ gridDim.x * gridDim.y * blockIdx.z;
int threadId = blockId * (blockDim.x * blockDim.y * blockDim.z)
  + (threadIdx.z * (blockDim.x * blockDim.y))
  + (threadIdx.y * blockDim.x)
  + threadIdx.x;
return threadId;
}