Category Archives: All

Think Silicon @CES2018

Think Silicon kicked-off successfully the new year at the Consumer Electronics Show  (@CES2018), in Las Vegas. CES is the place to be, when you are in the consumer electronics business and looking for the latest technology-trends and gadgets.

Think Silicon launched an ultra-low power Internet of Things (IoT) platform, created in cooperation with Synopsys. Designed to extend battery life of a wearable or embedded device for days (not for hours…) it runs just at 33MHz, yet still provides smartphone-like fast responsive graphics. The FPGA development platform contains a DesignWare® ARC EM5D Processor and Think Silicon’s® IP including a NEMA®|p single core GPU, NEMA®|DC Display-controller, and the NEMA®|GFX-API. The fully-fledged platform, is aimed to develop ultra-low power, connected wearables and low-power embedded (touch-) display devices.

7 New Video Uploads from the Samsung LPGPU2 Team!

Today Samsung has uploaded videos for 7 of their Vulkan test apps. Find out more about each one, including why it was written the way it was, and what we hope the LPGPU2 tool will identify when analysing them:

The LPGPU2 Vulkan Raymarching test app is designed to test the LPGPU2 profiling tool’s ability to analyse GPU compute-bound scenarios. All of the work for this app is confined to the fragment shader, which involves a computationally expensive loop detecting the distance a ray travels into the scene before colliding with geometry.

The LPGPU2 Vulkan Overdraw App displays a stack of translucent sheets that span almost the entire display area. The stack can be drawn either front to back or back to front. Can the LPGPU2 profiling tool detect a difference between these scenarios, and what are the implications of having many pixels repeatedly overdrawn?

The LPGPU2 Vulkan OverdrawTex App is geometrically identical to the Overdraw App – it displays a stack of translucent sheets that span the display area. The difference is that instead of colouring the triangle with a simple interpolation between values, a texture lookup is invoked. What happens when many more texture lookups are issued than there are pixels? Can the LPGPU2 profiling tool recognise this scenario?

The LPGPU2 Vulkan Menger Sponge app has a variable amount of geometry and a variable amount of detail on that geometry. The detail is implemented through a multi-level fragment shader algorithm. The result is an app that has a tuneable volume of geometry and independently tuneable compute burden.

The LPGPU2 Vulkan Hypercube app displays a representation of a 4D hypercube as it tumbles about the three most interesting planes of a 4D space. The scene contains a small amount of geometry and uses almost trivial shaders. The app is designed to have a low graphics overhead to find out what the LPGPU2 profiling tool reports in that situation.

The LPGPU2 Vulkan Globe app simulates a cloud-covered earth spinning in a starry sky. The number of cloud layers is variable, resulting in an app that specifically stresses the texture capabilities of the GPU.

The LPGPU2 Vulkan Uber app is the ‘kitchen sink’ of tests with its high levels of geometry, many textures, and heavy fragment- and vertex-processing, resulting in a low frame rate and very slow start-up time. Can the LPGPU2 profiling tool pick it apart?

 

Verifying behaviour with the LPGPU2 Toolsuite

Yesterday I was looked at the behaviour of one of our test apps (you can see an example of the sort of thing here  ) after observing it behaving strangely on one of our test devices.

The application I was using runs through a set of ‘apps’ for a fixed number of frames and then loops. The first app being run was running slowly and not as fluidly as the others.

The first thing I did was to take a capture with the LPGPU2 tool and get a high level overview of what was occurring:

Screen grab from tool – click to zoom

All of the counter data you can see if live and valid and reflects the system state at the time the graphics API calls from the application were being captured (GLES and EGL in this case).

Take a closer at the Regions of Interest (ROI) (shown in a blue gradient) and frames (shown in green)ribbons:

ROI and frames ribbons – click to zoom

In the above you can see that there are ROI that correspond to the heavy content being equally spaced along the timeline. You can also see how these ROI align with frames.

The more astute of you may notice that the ROI and frames are not completely consistent yet, but this is all part of the toolset validation and will be addressed as the project progresses.

 

PEGPUM 2018 Program Announcement!

The program for the PEGPUM 2018 workshop at HiPEAC 2018 in Manchester has been announced. More information can be found here. The program includes various technical presentations (from industry and academia) as well as a live demonstration showing the LPGPU2 toolchain analyzing GPU software.

LPGPU2 D5.3 Demonstration Video

In this the third video, we show off some more of the new features of LPGPU2 CodeXL including some of the new visualisations that are now available. In the video, we demonstrate the typical work flow for carrying out a power data profile capture session. Included in this workflow we also show you how to run the data analysis Feedback Engine to receive advice on issues found in the capture data.

 

The DC API, developed by Samsung and implemented by Think Silicon, TUB and Samsung is used by the application on the remote device which in this case is a standard Nexus Six Android phone to generate profile data sent over to CodeXL.

The visualisations seen in LPGPU2 CodeXL to display the API calls, frames and performance data along with the Help and feedback visualisations were created by Codeplay. The Feedback Engine’s advice, written in Lua by Samsung, is first seen in the power profile view as a Help ribbon under the frame data as Regions of Interest (ROI). From there a user can drill down to specific areas of interest or examine the advice given for that region in time.

Last but not least is a powerful new feature which allows the user to be able to compare the current profile session or any previous profile session with others so you are able to visualise graphically any differences for a counter over time.

Website refresh coming soon!

It’s been a wonderful year for LPGPU2 and next year is set to be even better!

To kick things off in style we’re going to have a refresh on the website, so watch this space!

Best wishes from all the LPGPU2 team!

 

New Starter at Think Silicon S.A. – The LPGPU2 Run-Time Developer

Katerina Terzi is a graduate of the Electrical and Computer Engineering Department of the National Technical University of Athens and a junior IC engineer in Think Silicon. She is currently involved in the hardware development of a new multicore GPU of the NEMA®|S series, and its prototyping on FPGA boards.

Katerina has significant expertise in hardware design and FPGA prototypes. In the LPGPU2 project, Katerina is involved in improving the power model for NEMA® GPUs and for developing a run-time system that is able to provide highly accurate, fine-grained power estimations when executing ISP (Image Signal Processing) applications in NEMA® GPUs.

Improving the look and feel of a pie chart

When developing the user interface for an application, no matter the platform, a great amount of time is spent refining the look and feel of the widgets that users interact with.

Sometimes, the GUI framework being used helps in this job, but sometimes there is the need to write your own versions of a known widget.

The LPGPU2 consortium is working on extending CodeXL with new functionality for profiling low-power GPUs. CodeXL’s user interface is developed using Qt 5.5, which is quite old by modern standards. This means that we have to write custom widgets once in a while in order to achieve our goals.

One of the visualisations we aim to provide is a pie chart. Pie charts are good for showing proportions of one group of elements relative to a set. However, Qt 5.5 does not provide some of the off-the-shelf chart components we require, so we had to develop our own pie chart.

Drawing a pie chart requires some calculations, but once that is sorted out we need to find the right look and feel for it.

The first version we came up with was far from ok, but it served to prove the point and allows us to keep working on the prototype (Before image). Unfortunately, there were a lot of things that didn’t feel right about the first version. The pie edges were drawn using black and they were quite jagged. The text for the labels was too big and very hard to read when confined in a small space. Finally, it was very difficult to associate the percentage amount of the corresponding label.

In order to improve this, the pie edge colours are now a light grey, this removes the attention from the edges and directs the eyes towards what is important in a pie chart: proportion. A small reduction in the font size combined with a better placement of the labels allows the association of a pie and label to be made more easily.

To remove the jagged edges, since we are using Qt, one can specify antialiasing flags to the object used for the actual drawing:

QPainter painter{ this };

painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing);

The last flag is only used when this component is used with an OpenGL renderer is available.

The following screenshots give an overview of how the look and feel of the pie chart widget was improved by this change. (Click to zoom)

Original View

Modified View

Think Silicon partners with SiFive

Think Silicon partners with SiFive’s DesignShare Ecosystem making its low-power graphics IP available through DesignShare and enabling companies of all sizes to develop custom silicon. SiFive, the first fabless provider of customized, open-source-enabled semiconductors, announced that Think Silicon, a leader in developing ultra-low power graphics IP technology, has joined the growing DesignShare economy. Through DesignShare, Think Silicon will make its complementary NEMA®|GPU and NEMA®|dc IP available for SiFive’s Freedom SoCs Platform at reduced upfront investment from customers. It is worth noting that the Power Models of NEMA®|GPUs (part of the NEMA® SW toolchain) were developed as part of the LPGPU2 EU-funded project.

With a silicon footprint 2.5 times smaller than competitive IP, Think Silicon’s proprietary compression techniques reduce the memory size six-fold, eliminating the need for external DDR memory. The result is a reduction of active power consumption by 73 percent, and 58 percent in idle mode.

For more information please view the related press release here.

OpenCL application captured and analysed by LPGPU’s Feedback Engine!

The screenshot below shows an OpenCL android application running on a Samsung device captured by the LPGPU2 tool suite and the captured API calls and performance counters (note synthetic counters were used in this test) used to provide feedback on possible ways to improve your application:

(click to zoom)

By continuing to use the site, you agree to the use of cookies. more information

The cookie settings on this website are set to "allow cookies" to give you the best browsing experience possible. If you continue to use this website without changing your cookie settings or you click "Accept" below then you are consenting to this.

Close