JanRobertMenzel.de

Forrester Research wirft einen Blick ins Jahr 2016 emnach werden in dem Jahr 375.000.000 Tablets verkauft. Gartner sagt voraus, dass 1/3 aller Tablets iPads sein werden. Soweit plausibel, aber zusätzlich wird Windows 8 eine rosige Zukunft auf Tablets vorausgesagt, ich schätze eher, dass Win8 auf allen Plattformen ein Nischendasein pflegen wird und wie Vista auf PCs erst durch den Nachfolger verdrängt werden kann.

Spannend ist noch folgendes Zitat: “Darüber hinaus prophezeit die Studie das Aufkommen einer neuen Form von Computern, sogenannten “Frames”. Dabei handelt es sich um stationäre Displays, die daran angedockte Tablets vielseitiger nutzbar machen. Solche Geräte werden vor allem in Konferenzräumen, Hotelzimmern und Cafés zur Ausstattung gehören und im Verbund mit Tablets Laptops ersetzen.”

Da setze ich dagegen: Der Vorteil eines Notebooks gegenüber einem Tablet ist die physische Tastatur beim viel tippen sowie stärkere Prozessoren, mehr RAM, vielseitigeres OS und mehr Speicher – der größere Bildschirm ist da nur einer der Unterschiede. Zwar kann man durch das Anschließen eines größeren Monitors oder Beamers mit Tablets auch Präsentationen halten und Filme schauen – dank AirPlay geht das aber heute schon und reicht bei weitem nicht, um Notebooks zu ersetzen. Wir werden künftig öfters mal Tablets als Notebookersatz sehen, an externen “Frames” wird das meiner Meinung aber nicht liegen.

Warten wir ab…

I just started a new sideproject, also a blog to collect thoughts and projects about real-time rendering, graphics and all the details that do on within a rendering pipeline: http://renderingpipeline.com.

This blog gets moved from one server to another, including some software changes. I hope everything will work again soon.

CVS was useful back then, SVN was a big step forward but git also is fun to use! After I used git in some private and non-private projects I don’t think I will ever look back

If you haven’t yet, give it a try. Even if your just coding for your self and a version control system seems to be overkill. Especially a distributed version control system sounds like overkill for a one-developer use-case but it works great and is quick to set up: git init and your ready to go.09

(I don’t need to change this often but every time I have to google it, so now I’m writing it down so I know where to find it

There are multiple ways to change the default company name:

• Globally for all projects: Set the company name in your Address Book entry or set a company name in the terminal with: defaults write com.apple.Xcode PBXCustomTemplateMacroDefinitions ‘{“ORGANIZATIONNAME” = “My Company”;}’
• For one project only: Since XCode 3.2 a company name can be set for a single project, select the projectname in the “Groups & Files” panel, rightklick it and select “Get Info“. In the “General” tab the company name for this project can be set.

Das Marktforschungsinstitut Gartner sagte 2008 gar das Ende der guten alten Maus voraus. Bei /. wird von “in den nächsten 5 Jahren”, also bis Mitte 2013 gesprochen. Ich setzte dagegen

First of all, there is the latest specification of OpenCL at the Khronos Registry. You will also find infos about the first extension there (cl_khr_gl_sharing).

MacResearch has a very good video podcast about OpenCL: http://macresearch.org/opencl. It is also available via iTunes.

AMD has a tutorial, it uses the C++ bindings which can also be found at the Khronos Registry.A more hi-level description from ATI can be found here. But nVidia has also a lot of stuff about OpenCL. Apple too has a nice overview online.

Sample code with XCode projects can be found at Apples developer site.

Khronos also hosts an OpenCL forum.

When looking at Apples OpenCL examples we see how to start with OpenCL: First we get one or more devices, then we create a context etc. We get our device id in Apples hello world example with the clGetDeviceIDs call:

cl_device_id device_id;
int err = clGetDeviceIDs(NULL, CL_DEVICE_TYPE_GPU, 1, &device_id, NULL);

But be warned, there is one error in this code and one possible incompatibility! First the error: clGetDeviceIDs returns a cl_int, not necessarily an int! Secound: passing NULL to clGetDeviceIDs as the first parameter is not covered in the OpenCL standart. What happens is implementation specific.

The correct way to do it would be to first get a valide platform ID:

cl_uint numberOfPlatforms = 0;
cl_int err = clGetPlatformIDs( 0, NULL, &numberOfPlatforms );

Now we know, how much platforms we have on this machine. Secound we can get all platforms:

cl_platform_id *platform = new cl_platform_id[numberOfPlatforms];
err = clGetPlatformIDs( numberOfPlatforms, platform, NULL );

Don’t forget the error checking! We could also just query the first platform. Now we can get all devices from platform 0:

cl_uint numberOfDevices;
err = clGetDeviceIDs( platform[0], CL_DEVICE_TYPE_ALL, 0, NULL, &numberOfDevices );
cl_device_id *device = new cl_device_id[numberOfDevices];
err = clGetDeviceIDs( platformID, CL_DEVICE_TYPE_ALL, numberOfDevices, device, NULL );

Error checking not included to make it more readable.

This code works fine on OS X and is portable. The few lines more don’t hurt anyone

Auch Computerworld versucht sich in einer Vorhersage, wie sich die Hardware bis 2015 verändern wird. Hier geht es darum, wie Notebooks in 7 Jahren aussehen werden (der Artikel stammt von 2008).

http://www.computerworld.com/s/article/9070158/Hello_gorgeous_Meet_the_laptop_you_ll_use_in_2015?pageNumber=1

Wie bei der GPU Vorhersage bin ich mal gespannt, wie merkwürdig uns das in 6 Jahren anmuten wird.

I played around a bit with Apples OpenCL Hello World example. To test OpenCL with large chunks of data you have to compile it as a 64bit application. But then it crashes because of a bug in the example code:

err = clGetKernelWorkGroupInfo(kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(int), &local, NULL);

This line can’t work in 64 bit mode because sizeof(int) isn’t equal to sizeof(size_t) anymore. But this will do the trick:

err = clGetKernelWorkGroupInfo(kernel, device_id, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &local, NULL);

The simple hello world is a bit faster on the GT120 than on the two quad core Xeons running at 2.26GHz. While this is no real world test (not even close) it still once more cool to see what a (not even hi-end) GPU can do.

Running on the CPUs allown, OpenCL can keep 16 cores (hyperthreading) bussy:

OpenCL seems to be much more fun than the old style GPGPU where you tricked OpenGL with shaders and textures into doing math for you