The document discusses RenderScript on LLVM. It describes RenderScript as a way to perform 3D rendering and compute tasks portably and with high performance on Android. It outlines the main components: an offline compiler that optimizes scripts, an online JIT compiler, and a runtime library. It provides an example of using RenderScript to convert an image to grayscale and discusses how scripts are compiled and executed to provide fast launch times.
Android High performance in GPU using opengles and renderscriptArvind Devaraj
This document discusses high performance graphics and compute using OpenGLES and RenderScript on Android. It begins with an introduction to graphics terms like primitives and textures. It then covers how graphics are handled by the GPU, describing the graphics pipeline and shader programs. It discusses using OpenGLES for Android graphics, including the GLSurfaceView class. RenderScript is introduced as a way to access the GPU for general purpose computing through a high-level API, with examples of image processing, encryption, and other applications.
RenderScript is a high-performance computation API that allows apps to run operations with automatic parallelization across CPU and GPU cores. It provides access to these features without needing to write code for different architectures or processor types. RenderScript code is compiled at runtime, so apps do not need to be recompiled for different devices. The document provides an overview of RenderScript and its system, basic usage, entry points, variables, pointers, memory management, and comparisons with OpenGL ES. It also includes examples of using RenderScript for single-image sampling, multi-image sampling, multi-pass effects, and generating a histogram.
High performance graphics and computation - OpenGL ES and RenderScript BlrDroid
This document discusses high performance graphics and compute using OpenGLES and RenderScript on Android. It introduces graphics terms and the graphics pipeline. It describes how to perform graphics operations using OpenGLES classes like GLSurfaceView and shaders. It also explains how RenderScript can be used to perform general purpose computing on the GPU for tasks like image processing, encryption, and mathematical functions.
Android OpenGL ES Game ImageGrabber Final ReportJungsoo Nam
This document discusses the development environment, tools, and code for an Android OpenGL ES game image grabbing project. It includes:
1. An overview of the development environment setup including Eclipse, the Android SDK, NDK, and build instructions.
2. A review of the Java and C/C++ source code, covering key classes, methods, and functions for initializing the grabber, starting/stopping recording, and hooking OpenGL ES calls.
3. Details on the C code structure including JNI interfaces and hooked OpenGL ES functions that redirect rendering to enable capturing.
4. Links to documents explaining the ELF file format and Linux hooking mechanisms used to modify function addresses at runtime.
This document provides information about OpenGL and EGL. It discusses OpenGL concepts like the rendering pipeline, shaders, and GLSL. It explains how to use OpenGL and GLSL on Android, including initializing, creating shaders, and rendering. It also covers EGL and how it acts as an interface between OpenGL and the native platform. It describes EGL objects like displays, surfaces, and contexts. It provides examples of basic EGL usage and lists EGL APIs for initializing, configuring, and managing graphics resources.
Presentation of NvFX: an effect layer that allows encapsulation of GLSL and/or D3D shading language.
The basic concept follows the footprints of NVIDIA CgFX
https://github.com/tlorach/nvFX
EGL is a native platform interface that provides a connection between OpenGL ES and the underlying native platform window system. It handles graphics context management, surface binding, and synchronization to enable high-performance 2D and 3D rendering using OpenGL ES. The basic usage of EGL involves initializing a display, configuring it, creating surfaces and a context, making the context current, rendering with OpenGL ES, and flushing buffers.
Experiments in Sharing Java VM Technology with CRubyMatthew Gaudet
IBM is developing a just-in-time (JIT) compiler called Testarossa based on its Open Runtime (OMR) toolkit. The goal is to integrate the JIT compiler into MRI Ruby to improve performance without changing how MRI works. So far, the JIT supports most opcodes and can run Rails applications, but performance gains are modest. IBM hopes to collaborate with the Ruby community to further optimize Ruby and help make it faster.
Android High performance in GPU using opengles and renderscriptArvind Devaraj
This document discusses high performance graphics and compute using OpenGLES and RenderScript on Android. It begins with an introduction to graphics terms like primitives and textures. It then covers how graphics are handled by the GPU, describing the graphics pipeline and shader programs. It discusses using OpenGLES for Android graphics, including the GLSurfaceView class. RenderScript is introduced as a way to access the GPU for general purpose computing through a high-level API, with examples of image processing, encryption, and other applications.
RenderScript is a high-performance computation API that allows apps to run operations with automatic parallelization across CPU and GPU cores. It provides access to these features without needing to write code for different architectures or processor types. RenderScript code is compiled at runtime, so apps do not need to be recompiled for different devices. The document provides an overview of RenderScript and its system, basic usage, entry points, variables, pointers, memory management, and comparisons with OpenGL ES. It also includes examples of using RenderScript for single-image sampling, multi-image sampling, multi-pass effects, and generating a histogram.
High performance graphics and computation - OpenGL ES and RenderScript BlrDroid
This document discusses high performance graphics and compute using OpenGLES and RenderScript on Android. It introduces graphics terms and the graphics pipeline. It describes how to perform graphics operations using OpenGLES classes like GLSurfaceView and shaders. It also explains how RenderScript can be used to perform general purpose computing on the GPU for tasks like image processing, encryption, and mathematical functions.
Android OpenGL ES Game ImageGrabber Final ReportJungsoo Nam
This document discusses the development environment, tools, and code for an Android OpenGL ES game image grabbing project. It includes:
1. An overview of the development environment setup including Eclipse, the Android SDK, NDK, and build instructions.
2. A review of the Java and C/C++ source code, covering key classes, methods, and functions for initializing the grabber, starting/stopping recording, and hooking OpenGL ES calls.
3. Details on the C code structure including JNI interfaces and hooked OpenGL ES functions that redirect rendering to enable capturing.
4. Links to documents explaining the ELF file format and Linux hooking mechanisms used to modify function addresses at runtime.
This document provides information about OpenGL and EGL. It discusses OpenGL concepts like the rendering pipeline, shaders, and GLSL. It explains how to use OpenGL and GLSL on Android, including initializing, creating shaders, and rendering. It also covers EGL and how it acts as an interface between OpenGL and the native platform. It describes EGL objects like displays, surfaces, and contexts. It provides examples of basic EGL usage and lists EGL APIs for initializing, configuring, and managing graphics resources.
Presentation of NvFX: an effect layer that allows encapsulation of GLSL and/or D3D shading language.
The basic concept follows the footprints of NVIDIA CgFX
https://github.com/tlorach/nvFX
EGL is a native platform interface that provides a connection between OpenGL ES and the underlying native platform window system. It handles graphics context management, surface binding, and synchronization to enable high-performance 2D and 3D rendering using OpenGL ES. The basic usage of EGL involves initializing a display, configuring it, creating surfaces and a context, making the context current, rendering with OpenGL ES, and flushing buffers.
Experiments in Sharing Java VM Technology with CRubyMatthew Gaudet
IBM is developing a just-in-time (JIT) compiler called Testarossa based on its Open Runtime (OMR) toolkit. The goal is to integrate the JIT compiler into MRI Ruby to improve performance without changing how MRI works. So far, the JIT supports most opcodes and can run Rails applications, but performance gains are modest. IBM hopes to collaborate with the Ruby community to further optimize Ruby and help make it faster.
Presented at the Bossa'10 conference in Manaus, Brazil. The presentation talks about the direction in which the Qt widgets are being developed and introduces the idea of Controls to Qt and QML.
Skiron - Experiments in CPU Design in DMithun Hunsur
This document discusses Skiron, an experimental CPU design project implemented in the D programming language. It provides an overview of Skiron, which simulates a RISC-inspired instruction set architecture. It describes the idioms and patterns used in D to define the instruction set and encoding in a way that is self-documenting and allows different parts of the software to stay in sync. It also discusses lessons learned, such as issues with delegates, as well as potential improvements to D's metaprogramming capabilities and standard library support for @nogc code. Realizing Skiron in hardware with an FPGA and making it self-hosting are presented as future goals.
Why scala is not my ideal language and what I can do with thisRuslan Shevchenko
- The document discusses some of the author's criticisms of Scala, including its use of implicit parameters to configure runtime behavior, and lack of good support for asynchronous programming.
- The author proposes some workarounds, like annotating imports to avoid implicit conflicts, and patching the compiler to add more information to Future exceptions. However, the ideal solution would be language changes or improvements to asynchronous abstractions like Async.
- Overall, the author argues that Scala is not ideal for some use cases like asynchronous programming, but provides some workarounds people can use in the meantime. The best solutions require changes to the language and standard library.
A Brief Introduction to the Qt Application FrameworkZachary Blair
The document discusses the Qt framework for cross-platform GUI and application development. It introduces Qt's container classes like QList and QMap, string handling class QString, and widget and GUI programming using signals and slots. Qt provides a standard set of widgets that look native on different platforms. It uses a signal/slot system and parent-child relationships for memory management. Developers can write code once and deploy applications across desktop and embedded platforms.
This document provides an overview of using QtScript to add scripting capabilities to Qt applications. It discusses embedding the QtScript engine, exposing C++ objects and APIs to scripts, debugging scripts, and integrating QtScript with Qt's meta-object system. The presentation includes examples of calculating values from scripts, configuring the script environment, calling into scripts from C++, and debugging scripts. The goal is to give attendees an understanding of how to make their Qt applications scriptable using QtScript.
EGL is an interface between Khronos rendering APIs (such as OpenGL and OpenGL ES) and the underlying native platform windowing system. It handles graphics context management, surface/buffer creation and binding, and rendering synchronization. EGL provides mechanisms for creating on-screen and off-screen rendering surfaces and graphics contexts that store OpenGL state. Key EGL functions include eglGetDisplay(), eglInitialize(), eglChooseConfig(), eglCreateWindowSurface(), and eglCreatePbufferSurface().
Presented as a pre-conference tutorial at the GPU Technology Conference in San Jose on September 20, 2010.
Learn about NVIDIA's OpenGL 4.1 functionality available now on Fermi-based GPUs.
This document discusses various techniques for integrating R with other programming languages and ecosystems. It begins by asking what to do after building a model in R, such as rewriting the code, integrating R with other languages, or implementing business logic directly in R. The document then covers options for integrating R at the command line, library level, and for calling R from other languages like C++. It also discusses using R for web applications via techniques like rApache, shiny, and openCPU. In the end it argues that R can be effectively used as part of an application infrastructure along with software engineering languages.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us as we explore the best of QML for mobile, embedded and desktop.
Part I will cover:
- Building Blocks of QML
- Qt Properties
- Declarative Code
Visual Studio를 이용한 x64 어셈블리 사용 방법에 대해 설명한다. 주요 변경점으로 64비트 레지스터 확장, 스택 기본 단위 변경, 새로운 레지스터 추가 등이 있다. Visual Studio에서 x64 어셈블리 사용을 위해 masm을 사용하고, 디버깅도 가능하다. x64에서 함수 호출 규약과 스택 사용 방식도
[GEG1] 10.camera-centric engine design for multithreaded rendering종빈 오
This document discusses using a camera-centric design for multithreaded rendering. It describes dividing the rendering process into per-camera render views. Commands are generated and collected in parallel on a per-object basis for each view. The commands are then executed sequentially per view type during serialization to the graphics device. This approach aims to improve load balancing and parallelization compared to other multithreaded rendering techniques.
Using the Android Native Development Kit (NDK)DroidConTLV
Android NDK is used to integrate C/C++ code into Android applications. Learn when and how to use it ; and what it implies to do so from development, integration within Eclipse and Android Studio, to distribution.
clWrap: Nonsense free control of your GPUJohn Colvin
The document discusses OpenCL and GPU programming. It provides an overview of OpenCL concepts like platforms, devices, contexts, kernels, command queues, buffers and images. It describes the OpenCL C API and some limitations. It then introduces clWrap, a D library that aims to provide a more type-safe and high-level wrapper for OpenCL. clWrap sits on top of the OpenCL C API and allows dropping down to it when needed. It also provides examples of mapping kernels and data to GPUs using clWrap.
This document introduces Kotlin, a statically typed programming language that runs on the Java Virtual Machine (JVM). It summarizes Kotlin's key features like concise syntax, null safety, interoperability with Java, and extension functions. The document also provides examples of Kotlin code for functions, properties, lambdas, and higher-order functions. It describes how Kotlin can be used for Android development and introduces libraries like Anko that simplify common Android tasks.
Most applications will need to communicate with other services or devices at some point, or at least save settings on the host computer. These concepts are covered in this module.
After introducing the generic concept behind devices, short examples show how to use files.
Afterwards, the module covers networking and its representation in Qt. In addition to providing classes for handling low level sockets, network managers simplify handling web service requests and responses like for the HTTP protocol. At the end, a short section explains the basics of different methods of parsing XML in Qt, including DOM trees, SAX, pull parsing and XQuery/XPath.
A section about internationalization demonstrates the process step-by-step, showing all required components to make your application multi-lingual.
The Android Native Development Kit (NDK) allows developers to write and embed native code like C/C++ in Android applications. It provides toolchains and headers to allow compilation of native code into libraries that can be called from Java code using the Java Native Interface. The NDK benefits applications requiring intensive CPU operations, games, or porting existing C/C++ code to Android. However, native code also increases complexity, so the NDK should only be used when truly needed rather than for preference of language. Sample projects demonstrate using the NDK to incorporate native code for tasks like threading and improving performance of algorithms.
JCConf 2018 - Retrospect and Prospect of JavaJoseph Kuo
This document summarizes Joseph S. Kuo's presentation on the retrospect and prospect of Java. It discusses the history and major features of Java versions from 1.0 to 11. Key developments include the addition of generics, lambdas, and modules. The presentation outlines new features in Java 9 like modularization and Java 10 like local variable type inference. It also previews upcoming features in Java 12 like switch expressions and raw string literals.
OpenSource API Server based on Node.js API framework built on supported Node.js platform with Tooling and DevOps. Use cases are Omni-channel API Server, Mobile Backend as a Service (mBaaS) or Next Generation Enterprise Service Bus. Key functionality include built in enterprise connectors, ORM, Offline Sync, Mobile and JS SDKs, Isomorphic JavaScript and Graphical API creation tool.
Analyzing the Performance of Mobile WebAriya Hidayat
This document discusses techniques for analyzing the performance of mobile web applications. It covers challenges like network variability, different device hardware, and continuous integration. Approaches mentioned include benchmarking, injecting instrumentation, emulation, and remote inspection. Strategies suggested are reducing complexity, replicating analysis on desktop, and tweaking at the system level. Tools mentioned include the Nexus One, Gingerbread, PhantomJS, and headless WebKit. The document provides examples and caveats for analyzing areas like network traffic, graphics commands, garbage collection, and JavaScript parsing.
Presented at the Bossa'10 conference in Manaus, Brazil. The presentation talks about the direction in which the Qt widgets are being developed and introduces the idea of Controls to Qt and QML.
Skiron - Experiments in CPU Design in DMithun Hunsur
This document discusses Skiron, an experimental CPU design project implemented in the D programming language. It provides an overview of Skiron, which simulates a RISC-inspired instruction set architecture. It describes the idioms and patterns used in D to define the instruction set and encoding in a way that is self-documenting and allows different parts of the software to stay in sync. It also discusses lessons learned, such as issues with delegates, as well as potential improvements to D's metaprogramming capabilities and standard library support for @nogc code. Realizing Skiron in hardware with an FPGA and making it self-hosting are presented as future goals.
Why scala is not my ideal language and what I can do with thisRuslan Shevchenko
- The document discusses some of the author's criticisms of Scala, including its use of implicit parameters to configure runtime behavior, and lack of good support for asynchronous programming.
- The author proposes some workarounds, like annotating imports to avoid implicit conflicts, and patching the compiler to add more information to Future exceptions. However, the ideal solution would be language changes or improvements to asynchronous abstractions like Async.
- Overall, the author argues that Scala is not ideal for some use cases like asynchronous programming, but provides some workarounds people can use in the meantime. The best solutions require changes to the language and standard library.
A Brief Introduction to the Qt Application FrameworkZachary Blair
The document discusses the Qt framework for cross-platform GUI and application development. It introduces Qt's container classes like QList and QMap, string handling class QString, and widget and GUI programming using signals and slots. Qt provides a standard set of widgets that look native on different platforms. It uses a signal/slot system and parent-child relationships for memory management. Developers can write code once and deploy applications across desktop and embedded platforms.
This document provides an overview of using QtScript to add scripting capabilities to Qt applications. It discusses embedding the QtScript engine, exposing C++ objects and APIs to scripts, debugging scripts, and integrating QtScript with Qt's meta-object system. The presentation includes examples of calculating values from scripts, configuring the script environment, calling into scripts from C++, and debugging scripts. The goal is to give attendees an understanding of how to make their Qt applications scriptable using QtScript.
EGL is an interface between Khronos rendering APIs (such as OpenGL and OpenGL ES) and the underlying native platform windowing system. It handles graphics context management, surface/buffer creation and binding, and rendering synchronization. EGL provides mechanisms for creating on-screen and off-screen rendering surfaces and graphics contexts that store OpenGL state. Key EGL functions include eglGetDisplay(), eglInitialize(), eglChooseConfig(), eglCreateWindowSurface(), and eglCreatePbufferSurface().
Presented as a pre-conference tutorial at the GPU Technology Conference in San Jose on September 20, 2010.
Learn about NVIDIA's OpenGL 4.1 functionality available now on Fermi-based GPUs.
This document discusses various techniques for integrating R with other programming languages and ecosystems. It begins by asking what to do after building a model in R, such as rewriting the code, integrating R with other languages, or implementing business logic directly in R. The document then covers options for integrating R at the command line, library level, and for calling R from other languages like C++. It also discusses using R for web applications via techniques like rApache, shiny, and openCPU. In the end it argues that R can be effectively used as part of an application infrastructure along with software engineering languages.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us as we explore the best of QML for mobile, embedded and desktop.
Part I will cover:
- Building Blocks of QML
- Qt Properties
- Declarative Code
Visual Studio를 이용한 x64 어셈블리 사용 방법에 대해 설명한다. 주요 변경점으로 64비트 레지스터 확장, 스택 기본 단위 변경, 새로운 레지스터 추가 등이 있다. Visual Studio에서 x64 어셈블리 사용을 위해 masm을 사용하고, 디버깅도 가능하다. x64에서 함수 호출 규약과 스택 사용 방식도
[GEG1] 10.camera-centric engine design for multithreaded rendering종빈 오
This document discusses using a camera-centric design for multithreaded rendering. It describes dividing the rendering process into per-camera render views. Commands are generated and collected in parallel on a per-object basis for each view. The commands are then executed sequentially per view type during serialization to the graphics device. This approach aims to improve load balancing and parallelization compared to other multithreaded rendering techniques.
Using the Android Native Development Kit (NDK)DroidConTLV
Android NDK is used to integrate C/C++ code into Android applications. Learn when and how to use it ; and what it implies to do so from development, integration within Eclipse and Android Studio, to distribution.
clWrap: Nonsense free control of your GPUJohn Colvin
The document discusses OpenCL and GPU programming. It provides an overview of OpenCL concepts like platforms, devices, contexts, kernels, command queues, buffers and images. It describes the OpenCL C API and some limitations. It then introduces clWrap, a D library that aims to provide a more type-safe and high-level wrapper for OpenCL. clWrap sits on top of the OpenCL C API and allows dropping down to it when needed. It also provides examples of mapping kernels and data to GPUs using clWrap.
This document introduces Kotlin, a statically typed programming language that runs on the Java Virtual Machine (JVM). It summarizes Kotlin's key features like concise syntax, null safety, interoperability with Java, and extension functions. The document also provides examples of Kotlin code for functions, properties, lambdas, and higher-order functions. It describes how Kotlin can be used for Android development and introduces libraries like Anko that simplify common Android tasks.
Most applications will need to communicate with other services or devices at some point, or at least save settings on the host computer. These concepts are covered in this module.
After introducing the generic concept behind devices, short examples show how to use files.
Afterwards, the module covers networking and its representation in Qt. In addition to providing classes for handling low level sockets, network managers simplify handling web service requests and responses like for the HTTP protocol. At the end, a short section explains the basics of different methods of parsing XML in Qt, including DOM trees, SAX, pull parsing and XQuery/XPath.
A section about internationalization demonstrates the process step-by-step, showing all required components to make your application multi-lingual.
The Android Native Development Kit (NDK) allows developers to write and embed native code like C/C++ in Android applications. It provides toolchains and headers to allow compilation of native code into libraries that can be called from Java code using the Java Native Interface. The NDK benefits applications requiring intensive CPU operations, games, or porting existing C/C++ code to Android. However, native code also increases complexity, so the NDK should only be used when truly needed rather than for preference of language. Sample projects demonstrate using the NDK to incorporate native code for tasks like threading and improving performance of algorithms.
JCConf 2018 - Retrospect and Prospect of JavaJoseph Kuo
This document summarizes Joseph S. Kuo's presentation on the retrospect and prospect of Java. It discusses the history and major features of Java versions from 1.0 to 11. Key developments include the addition of generics, lambdas, and modules. The presentation outlines new features in Java 9 like modularization and Java 10 like local variable type inference. It also previews upcoming features in Java 12 like switch expressions and raw string literals.
OpenSource API Server based on Node.js API framework built on supported Node.js platform with Tooling and DevOps. Use cases are Omni-channel API Server, Mobile Backend as a Service (mBaaS) or Next Generation Enterprise Service Bus. Key functionality include built in enterprise connectors, ORM, Offline Sync, Mobile and JS SDKs, Isomorphic JavaScript and Graphical API creation tool.
Analyzing the Performance of Mobile WebAriya Hidayat
This document discusses techniques for analyzing the performance of mobile web applications. It covers challenges like network variability, different device hardware, and continuous integration. Approaches mentioned include benchmarking, injecting instrumentation, emulation, and remote inspection. Strategies suggested are reducing complexity, replicating analysis on desktop, and tweaking at the system level. Tools mentioned include the Nexus One, Gingerbread, PhantomJS, and headless WebKit. The document provides examples and caveats for analyzing areas like network traffic, graphics commands, garbage collection, and JavaScript parsing.
Improving app performance with Kotlin CoroutinesHassan Abid
Coroutines were added to Kotlin in version 1.3 and since then they became a popular choice for android developers to simplify code that executes asynchronously. Coroutines are lightweight threads and on android they help to solve the primary problems of long running tasks that might block the main thread and also providing safety for offloading network or disk operations from the main thread. This talk covers how coroutines work with architecture components
GraalVM allows building native applications from Java and other JVM languages. It includes a new just-in-time compiler called Graal and the Truffle framework for building language interpreters. GraalVM also includes Sulong, which allows running LLVM-based languages on the JVM. The presenter discussed using GraalVM to build a native executable for a Zookeeper CLI tool called zkstat from Java code using techniques like ahead-of-time compilation with SubstrateVM, configuring reflection, and building a Docker image for distribution.
Hybrid Apps (Native + Web) via QtWebKitAriya Hidayat
This document discusses hybrid apps that combine native and web technologies using QtWebKit. It provides an overview of QtWebKit and how it can be used to embed web content in native apps. It describes various tools, technologies and frameworks that can be used to build hybrid apps, including JavaScript, CSS, Canvas, WebGL, and tools for debugging, testing, and designing hybrid apps. It concludes that web technologies are advancing rapidly and hybrid approaches can help migration, while tools still need to catch up to support building high quality hybrid apps.
HKG15-300: Art's Quick Compiler: An unofficial overviewLinaro
HKG15-300: Art's Quick Compiler: An unofficial overview
---------------------------------------------------
Speaker: Matteo Franchin
Date: February 11, 2015
---------------------------------------------------
★ Session Summary ★
One of the important technical novelties introduced with the recent release of Android Lollipop is the replacement of Dalvik, the VM which was used to execute the bytecode produced from Java apps, with ART, a new Android Run-Time. One interesting aspect in this upgrade is that the use of Just-In-Time compilation was abandoned in favour of Ahead-Of-Time compilation. This delivers better performance [1], also leaving a good margin for future improvements. ART was designed to support multiple compilers. The compiler that shipped with Android Lollipop is called the “Quick Compiler”. This is simple, fast, and is derived from Dalvik’s JIT compiler. In 2014 our team at ARM worked in collaboration with Google to extend ART and its Quick Compiler to add support for 64-bit and for the A64 instruction set. These efforts culminated with the recent release of the Nexus 9 tablet, the first 64-bit Android product to hit the market. Despite Google’s intention of replacing the Quick Compiler with the so-called “Optimizing Compiler”, the job for the the Quick Compiler is not yet over. Indeed, the Quick Compiler will remain the only usable compiler in Android Lollipop. Therefore, all competing parties in the Android ecosystem have a huge interest in investigating and improving this component, which will very likely be one of the battlegrounds in the Android benchmark wars of 2015. This talk aims to give an unofficial overview of ART’s Quick compiler. It will first focus on the internal organisation of the compiler, adopting the point of view of a developer who is interested in understanding its limitations and strengths. The talk will then move to exploring the output produced by the compiler, discussing possible strategies for improving the generated code, while keeping in mind that this component may have a limited life-span, and that any long-term work would be better directed towards the Optimizing Compiler. [1] The ART runtime, B. Carlstrom, A. Ghuloum, and I. Rogers, Google I/O 2014,https://www.youtube.com/watch?v=EBlTzQsUoOw
--------------------------------------------------
★ Resources ★
Pathable: https://hkg15.pathable.com/meetings/250804
Video: https://www.youtube.com/watch?v=iho-e7EPHk0
Etherpad: N/A
---------------------------------------------------
★ Event Details ★
Linaro Connect Hong Kong 2015 - #HKG15
February 9-13th, 2015
Regal Airport Hotel Hong Kong Airport
---------------------------------------------------
http://www.linaro.org
http://connect.linaro.org
WinDbg is a low-level debugger for Windows that provides features like usermode debugging, kernel debugging, post-mortem debugging, and support for debugging extensions. It can be used to debug crashes, analyze memory leaks, find deadlocks, and investigate other issues when the higher-level Visual Studio debugger is not sufficient. The document provides examples of using WinDbg commands and extensions like SOS to debug memory leaks, analyze crashes based on offset or dump files, and investigate .NET deadlocks.
Using Smalltalk for controlling robotics systemsSerge Stinckwich
This document discusses using Smalltalk for controlling robotics systems. It provides an introduction to developing embedded systems in Smalltalk and highlights some past projects that have used Smalltalk for robotics and embedded applications. It outlines advantages of Smalltalk such as its simple syntax, portability, uniformity, and dynamism. Examples are given of generating code from Smalltalk for other robotics platforms and simulating robotics applications in Smalltalk.
JVM Mechanics: When Does the JVM JIT & Deoptimize?Doug Hawkins
HotSpot promises to do the "right" thing for us by identifying our hot code and compiling "just-in-time", but how does HotSpot make those decisions?
This presentation aims to detail how HotSpot makes those decisions and how it corrects its mistakes through a series of demos that you run yourself.
The document discusses Google Web Toolkit (GWT), a development toolkit that allows developers to write client-side applications in Java and compile them to optimized JavaScript that runs across browsers, providing features like Ajax functionality, browser compatibility, and optimizations for both developers and users. GWT uses generators, translators, and linkers to compile Java code into JavaScript that can run directly in web browsers.
The document discusses the JavaScript engine architecture in SpiderMonkey. It describes the roles of the interpreter, baseline just-in-time (JIT) compiler, and IonMonkey JIT compiler. The interpreter parses JavaScript code into bytecode, which is then run by interpreting and invoking C++ functions. The baseline JIT compiles hot bytecode into optimized assembly code. IonMonkey performs a full optimization of JavaScript functions by compiling them into a graph representation. Bailouts can occur if type assumptions made during JIT compilation turn out to be incorrect.
The document summarizes several new features proposed for OpenStack at the OpenStack Summit Tokyo 2015, including:
1. Log Request ID mapping across OpenStack components like Nova, Cinder, Glance, and Neutron to improve logging and tracing of API calls.
2. Masakari, a new project providing VM high availability for OpenStack Compute.
3. Improving unshelve performance in Nova by caching VM images locally to avoid downloading during reboot.
The document discusses Google Web Toolkit (GWT), a development toolkit that allows developers to write client-side applications in Java and have their code compiled into optimized JavaScript that runs across browsers. It provides an overview of GWT, demonstrates its capabilities, and discusses how it optimizes applications for both developers and users. GWT aims to simplify Ajax development, improve cross-browser portability, and increase application performance.
Grow and Shrink - Dynamically Extending the Ruby VM StackKeitaSugiyama1
This document summarizes a presentation about dynamically extending the Ruby VM stack. It discusses two methods for extending the stacks - stretching and chaining. Stretching grows the stacks upwards when they reach the maximum size, while chaining implements the call stack as a linked list so only the internal stack needs growing. The implementation aims to make stack extensions safe and efficient for development by prohibiting access to old stacks and frequently triggering extensions for testing. Benchmarks show chaining has lower execution time than stretching but is still slower than the default implementation due to overhead from moving stacks and indirect access. Initial stack size has little effect on performance. The goal is to reduce memory usage through dynamic stack sizing.
Here are the key things GWT's generators do to enable RPCs:
1. Generate serialization/deserialization code:
- The generator analyzes the service interface and generates code to serialize/deserialize requests and responses to/from JSON or other formats.
2. Generate client-side proxy classes:
- Proxy classes handle calling the service and mapping requests/responses to Java objects on the client.
3. Handle asynchronous callbacks:
- The proxy implements callbacks so the client code receives responses asynchronously without blocking.
4. Handle cross-domain requests:
- GWT handles any cross-domain issues behind the scenes via techniques like JSONP.
So in summary, the generators automate all the boiler
The debug process constitutes an important part in an app's development cycle. Knowing the (right) tools and techniques means you can optimizes time and therefore costs. In this session we will see a number of techniques to optimize debugging of iOS applications exploiting the power of Xcode, LLDB and other support tools.
The document discusses LLVM and its use in building programming language compilers and runtimes. It provides an overview of LLVM, including its core components like its intermediate representation (IR), optimizations, and code generation capabilities. It also discusses how LLVM is used in various applications like Android, browsers, and graphics processing. Examples are given of using Clang and LLVM to compile and run a simple C program.
This document discusses deployment strategies for Ruby on Rails applications. It covers common components of the "Rails stack" including databases, caching, application servers and load balancers. Popular options are mentioned like Nginx, Memcached, Mongrel and Capistrano. Performance optimization techniques are also summarized, such as caching, background processing and memory usage strategies. The document concludes with an overview of common deployment processes and challenges.
Hybrid Apps (Native + Web) using WebKitAriya Hidayat
In term of innovations and mobile availability, WebKit is known to be the premier web rendering engine with the leading support for web standards such as HTML5, CSS3, and SVG. On MeeGo platform, WebKit can be leveraged easily via the use QtWebKit module which combines powerful WebKit features with the ease of use of Qt. The ground of developing applications using native technologies has been much explored, however there are still confusions, myths and misunderstanding as to what can be achieved with web technologies and hybrid native-web approach. This talk will highlight several tools and best practices in developing and testing good looking, feature-rich, and hardware-accelerated applications using web technologies targeting MeeGo platform in particular.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
20 Comprehensive Checklist of Designing and Developing a WebsitePixlogix Infotech
Dive into the world of Website Designing and Developing with Pixlogix! Looking to create a stunning online presence? Look no further! Our comprehensive checklist covers everything you need to know to craft a website that stands out. From user-friendly design to seamless functionality, we've got you covered. Don't miss out on this invaluable resource! Check out our checklist now at Pixlogix and start your journey towards a captivating online presence today.
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Enchancing adoption of Open Source Libraries. A case study on Albumentations.AIVladimir Iglovikov, Ph.D.
Presented by Vladimir Iglovikov:
- https://www.linkedin.com/in/iglovikov/
- https://x.com/viglovikov
- https://www.instagram.com/ternaus/
This presentation delves into the journey of Albumentations.ai, a highly successful open-source library for data augmentation.
Created out of a necessity for superior performance in Kaggle competitions, Albumentations has grown to become a widely used tool among data scientists and machine learning practitioners.
This case study covers various aspects, including:
People: The contributors and community that have supported Albumentations.
Metrics: The success indicators such as downloads, daily active users, GitHub stars, and financial contributions.
Challenges: The hurdles in monetizing open-source projects and measuring user engagement.
Development Practices: Best practices for creating, maintaining, and scaling open-source libraries, including code hygiene, CI/CD, and fast iteration.
Community Building: Strategies for making adoption easy, iterating quickly, and fostering a vibrant, engaged community.
Marketing: Both online and offline marketing tactics, focusing on real, impactful interactions and collaborations.
Mental Health: Maintaining balance and not feeling pressured by user demands.
Key insights include the importance of automation, making the adoption process seamless, and leveraging offline interactions for marketing. The presentation also emphasizes the need for continuous small improvements and building a friendly, inclusive community that contributes to the project's growth.
Vladimir Iglovikov brings his extensive experience as a Kaggle Grandmaster, ex-Staff ML Engineer at Lyft, sharing valuable lessons and practical advice for anyone looking to enhance the adoption of their open-source projects.
Explore more about Albumentations and join the community at:
GitHub: https://github.com/albumentations-team/albumentations
Website: https://albumentations.ai/
LinkedIn: https://www.linkedin.com/company/100504475
Twitter: https://x.com/albumentations
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
2. Outline
Overview of RenderScript (what, why, how, ...)
Components
Offline Compiler
Online JIT Compiler
RenderScript Runtime
Put Everything Together:
Producing a .apk: HelloCompute Example
Running the .apk: Fast launch time & On-device linking
Conclusions
3. What is RenderScript?
It is the future of Android 3D Rendering and Compute
Portability
Performance
Usability
C99 plus some extensions
Vector operations
Function overloading
rsForEach
Current clients include:
Books app
YouTube app
MovieStudio app
Live wallpapers + 3D Launcher
Challenging compiler + runtime work
4. RenderScript Components
Offline compiler (llvm-rs-cc)
Convert script files into portable bitcode and reflected
Java layer
Online JIT compiler (libbcc)
Translate portable bitcode to appropriate machine code
(CPU/GPU/DSP/...)
Runtime library support (libRS)
Manage scripts from Dalvik layer
Also provide basic support libraries (math functions, etc.)
5. Offline Compiler: llvm-rs-cc
Based on Clang/LLVM
Clang and LLVM are popular open source compiler
projects
Clang - C/C++/ObjC compiler frontend
LLVM - Optimizing compiler backend
Key features:
Cleverly reuse Clang abstract syntax tree (AST) to reflect
information back to Java layer
Embeds metadata within bitcode (type, ...)
All bitcode supplied as a resource within .apk container
8. Online JIT Compiler: libbcc
Based on LLVM: Lighten it to fit in Android devices
Currently supports ARM and x86
Future targets include GPU/DSP
Performs target-specific optimizations and code generation
Key features:
Reflection for libRS: Provides hooks for runtime to access
embedded metadata
Caches JITed scripts to improve startup time
On-device linking: Links dynamically against runtime library
functions (math)
10. RenderScript Runtime: libRS
Manages Scripts and other RenderScript objects
Script, Type, Element, Allocation, Mesh,
ProgramFragment, ProgramRaster, ProgramStore,
ProgramVertex, Sampler, various matrix and primitive
types
Provides implementation of runtime libraries (math, time,
drawing, ref-counting, ...)
Allows allocation, binding of objects to script globals
Work distribution (multi-threading)
Message-passing between Dalvik and script-side
11. HelloCompute Example
Available in Honeycomb SDK samples
Converts a bitmap image to grayscale
Exploits parallelism by using rsForEach on every pixel of an
allocation (simple dot product of RGB values)
mono.rs -> mono.bc + reflected to ScriptC_mono.java
16. Running .apk Needs Fast Launch, but...
LLVM's optimizations may take time. E.g., for -O3, 750ms for
1500 lines of RenderScript app.
There are still many
lines of LLVM code
on a smaller app:
17. Caching: Launch fast, while allowing
heavy optimizations ahead-of-time
Apps libbcc without AOT. libbcc with AOT.
launch time (libbcc) launch time (libbcc)
Books 1218ms 9ms
Youtube 842ms 4ms
Wallpaper
MagicSmoke 182ms 3ms
Halo 127ms 3ms
Balls 149ms 3ms
SceneGraph 146ms 90ms
Model 104ms 4ms
Fountain 57ms 3ms
18. On-Device Linking
Design:
Provide generic runtime library (lib*.bc), while
allow CPU/GPU vendors to provide their specialized lib*.
bc, and
reduce latency of function invocation
An example: RenderScript's runtime (libclcore.bc) comes
with vector operations. Xoom's libclcore will have different
CPU/GPU support (VFP3-16) than Nexus S's (NEON).
Implementation:
Linking at LLVM bitcode level
Using Link-Time Optimization to inline functions
and perform constant propagation
19. Conclusions
RenderScript
Portable, high-performance, and developer-friendly
3D graphics + compute acceleration path
Hide complexity through compiler + runtime
C99-based + rsForEach
Ample use of reflection
Library functions
Opaque managed types + reference counting
Lightweight JIT:
Fast launch time
On-device linking
See http://developer.android.com/ for the latest info
21. Adventures in AST Annotation
RenderScript runtime manages a bunch of types
Allocations in the sample script (plus other things too)
How do we know when they can be cleaned up?
Java-Side ???
Script-Side ???
Reference Counting
rsSetObject(), rsClearObject()
Developers do not want to micro-manage opaque blobs
Solution is to dynamically annotate script code to use
these functions in the appropriate spots
22. Annotating the AST
AST - Abstract Syntax Tree - follows source code in Clang
Update this in-place before we emit bitcode
Need to do a few types of conversions on variables with an
RS object type (rs_* types, not including rs_matrix*)
Assignments -> rsSetObject(&lhs, rhs)
Insert destructor calls as rsClearObject(&local) for locals
Global variables get cleaned up by runtime after script
object is destroyed
23. Reference Counting Example
rs_font globalIn[10], globalOut;
void foo(int j) {
rs_font localUninit;
localUninit = globalIn[0];
for (int i = 0; i < j; i++) {
rs_font forNest = globalIn[i];
switch (i) {
case 3:
return;
case 7:
continue;
default:
break;
}
localUninit = forNest;
}
globalOut = localUninit;
return;
}
24. RS Object Local Variables
rs_font globalIn[10], globalOut;
void foo(int j) {
rs_font localUninit;
localUninit = globalIn[0];
for (int i = 0; i < j; i++) {
rs_font forNest = globalIn[i];
switch (i) {
case 3:
return;
case 7:
continue;
default:
break;
}
localUninit = forNest;
}
globalOut = localUninit;
return;
}
25. Assignment -> rsSetObject()
rs_font globalIn[10], globalOut;
void foo(int j) {
rs_font localUninit;
rsSetObject(&localUninit, globalIn[0]); // Simple translation to call-expr
for (int i = 0; i < j; i++) {
rs_font forNest;
rsSetObject(&forNest, globalIn[i]); // Initializers must be split before conversion
switch (i) {
case 3:
return;
case 7:
continue;
default:
break;
}
rsSetObject(&localUninit, forNest);
}
rsSetObject(&globalOut, localUninit);
return;
}
26. Insert Destructor Calls
rs_font globalIn[10], globalOut;
void foo(int j) {
rs_font localUninit;
rsSetObject(&localUninit, globalIn[0]);
for (int i = 0; i < j; i++) {
rs_font forNest;
rsSetObject(&forNest, globalIn[i]);
switch (i) {
case 3:
rsClearObject(&localUninit); // Return statements always require that you destroy
rsClearObject(&forNest); // any in-scope local objects (inside-out).
return;
case 7:
rsClearObject(&forNest); // continue scopes to for-loop, so destroy forNest
continue;
default:
break; // break scopes to switch-stmt, so do nothing
}
rsSetObject(&localUninit, forNest);
rsClearObject(&forNest); // End of for-loop scope, so destroy forNest
}
rsSetObject(&globalOut, localUninit);
rsClearObject(&localUninit); // End outer scope (before return)
return;
}