Home
Search results “Gcc optimization options”
GCC/Clang Optimizations for Embedded Linux - Khem Raj, Comcast RDK
 
54:05
GCC/Clang Optimizations for Embedded Linux - Khem Raj, Comcast RDK This talk will cover how gcc and clang/LLVM compilers can boost the Embedded Linux Development by optimizing for size and performance on constrained systems. It will also cover specific commandline options that are available for tuning the programs for power/performance/size optimizations and how they impact each other. It will also discuss how can we get better code by helping the compilers by writing "friendly" code. Primarily it will focus on C but will also cover C++. Since we have multiple architectures supporting Embedded Linux, we will also discuss architecture specific tunings and optimizations that can be taken advantage. About Khem Raj Working on deploying Yocto Project/OpenEmbedded into Comcast's community Reference Design Kit for STB, Gateway and IoT platforms. Working on designing optimal open source software development and contribution procedures. Previously worked at Juniper where he was responsible to creating and maintaining Linux base operating system for upcoming Junos( Juniper's Network Operating System) again it was based on Yocto project. He is a contributor and maintainer for pieces in OpenEmbedded and Yocto Project. Last he spoke at ELCE Berlin in 2016
Views: 1444 The Linux Foundation
CppCon 2016: Tim Haines “Improving Performance Through Compiler Switches..."
 
01:06:22
http://CppCon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2016 — Much attention has been given to what modern optimizing compilers can do with your code, but little is ever said as to how to make the compiler invoke these optimizations. Of course, the answer is compiler switches! But which ones are needed to generate the best code? How many switches does it take to get the best performance? How do different compilers compare when using the same set of switches? I explore all of these questions and more to shed light on the interplay between C++ compilers and modern hardware drawing on my work in high performance scientific computing. Enabling modern optimizing compilers to exploit current-generation processor features is critical to success in this field. Yet, modernizing aging codebases to utilize these processor features is a daunting task that often results in non-portable code. Rather than relying on hand-tuned optimizations, I explore the ability of today's compilers to breathe new life into old code. In particular, I examine how industry-standard compilers like those from gcc, clang, and Intel perform when compiling operations common to scientific computing without any modifications to the source code. Specifically, I look at streaming data manipulations, reduction operations, compute-intensive loops, and selective array operations. By comparing the quality of the code generated and time to solution from these compilers with various optimization settings for several different C++ implementations, I am able to quantify the utility of each compiler switch in handling varying degrees of abstractions in C++ code. Finally, I measure the effects of these compiler settings on the up-and-coming industrial benchmark High Performance Conjugate Gradient that focuses more on the effects of the memory subsystem than current benchmarks like the traditional High Performance LinPACK suite. — Tim Haines University of Wisconsin-Madison PhD Candidate Madison, WI I am a third-year PhD candidate working in computational astrophysics. My undergraduate work was in computer science, physics, and mathematics, and I have an M.S. in physics. Fundamentally, my interests lie in developing software systems to try to answer difficult scientific questions combining modern parallel programming techniques in C++ with heterogeneous and massively parallel hardware. As such, I have a keen interest in the application of high performance computing to scientific problems (often called "scientific computing"). I spend most of my days attempting to design and build flexible, abstract software for parallel hardware in C++. Currently, I am part of a collaboration including the University of Washington and the University of Illinois at Urbana-Champagne working on the development of the cosmological N-body code CHArm N-body GrAvity solver (ChaNGa). Although it has excellent scaling properties (up to 512K processors with 93% efficiency), the node-level performance is sub-optimal. I am now working with a CS PhD candidate at UIUC to replace much of the C++98 codebase with C++11 and incorporate GPU computing using the CUDA runtime. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 15403 CppCon
Compiler Optimisation Lecture 2
 
31:10
This lecture is the coursework for the 2017 Compiler Optimisation course that I teach at the University of Edinburgh. If you are watching this and it is not 2017, you are probably watching the wrong video! GCC Options are at: http://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html The benchmarks are at: https://docs.google.com/file/d/0B5GasMlWJhTOaTdvaFkzUzNobDQ The course webpage is at: http://www.inf.ed.ac.uk/teaching/courses/copt/
Automatic Tuning of Compiler Options using irace - GNU Tools Cauldron 2018
 
09:25
Presented by Manuel López-Ibáñez at GNU Tools Cauldron 2018 While modern compilers usually offer different levels of optimization as possible defaults, they have a larger number of command-line options and numerical parameters that impact properties of the generated machine-code. The irace package (https://cran.r-project.org/package=irace) is a method for automatic algorithm configuration that can handle numerical and discrete options and optimizes their settings according to a given metric (such as runtime) over a large number of noisy (stochastic) benchmarks. When adapted to the tuning of compiler options in GCC, irace becomes an alternative to Acovea, OpenTuner and TACT with some desirable features. Experimental results show that, depending on the specific code to be optimized, speed-ups of up to 1.4 when compared to the -O2 and -O3 optimization flags are possible. I'm presenting on behalf of the other authors who will not attend. They did all the experiments using our tool (irace) and advice from me. I hope the irace package will be interesting to GCC developers and users (it is GPL).
Views: 137 Embecosm
C Programming Optimized Code, RAMifications
 
03:50
Let's take a look at what happens to our function when we compile it with compiler optimizations enabled. What is optimized code? What is function in-lining? See how the gcc compiler strips off the CDECL calling convention wrappers (stack push call and ret instruction overhead) and embeds our functions code directly into main() when we enable the gcc optimize for size flag, -Os. This is just one of the many, many optimizing steps a compiler might do. We can also tell it to unroll loops, or treat the stack differently. See "man gcc" for options. But let's not enable too many of these optimizations, or risk ricing up our code. Optimized code can run a little bit faster or take up a little bit less memory. However, the compiler flags we choose can make significant changes to the final assembly language output. This may not be a problem for some, but in the future we might want to know about this in case we decide to do some non-standard self-modifying code experiments. Resources: http://www.iso-9899.info/wiki/Main_Page http://www.cs.princeton.edu/~benjasik/gdb/gdbtut.html http://www.phiral.net/linuxasmone.htm http://en.wikibooks.org/wiki/Category:X86_Disassembly http://en.wikipedia.org/wiki/X86_calling_conventions#cdecl
Views: 7547 Henry Kroll
Cauldron 2013 - Impact of Different Compiler Options on Energy Consumption
 
29:32
Presenter: James Pallister Abstract: This talk describes an extensive study into how compiler optimization affects the energy usage of benchmarks on different platforms. We use an fractional factorial design to explore the energy consumption of 87 optimizations GCC performs when compiling 10 benchmarks for five different embedded platforms. Hardware power measurements on each platform are taken to ensure all architectural effects on the energy are captured and that no information is lost due to inaccurate or incomplete models. We find that in the majority of cases execution time and energy consumption are highly correlated, but the effect a particular optimization may have is non-trivial due to its interactions with other optimizations. There is no one optimization that is universally positive for run-time or energy consumption, as the structure of the benchmark heavily influences the optimization's effectiveness. This talk presents the results and conclusions gain from the project we introduced last year at the previous GNU Tools Cauldron.
Views: 207 Diego Novillo
Parser and Lexer — How to Create a Compiler part 1/5 — Converting text into an Abstract Syntax Tree
 
51:04
In this tool-assisted education video I create a parser in C++ for a B-like programming language using GNU Bison. For the lexicographical analysis, a lexer is generated using re2c. This is part of a multi-episode series. In the next video, we will focus on optimization. Downloads: — https://github.com/bisqwit/compiler_series/tree/master/ep1 All the material associated with this episode can be downloaded here. Acknowledgements: — Picture: Processors :: Jason Rogers — Music¹: Aryol :: The Strategy Continues :: Kyohei Sada (converted into MIDI and played through OPL3 emulation through homebrew software) — Music²: Star Ocean :: Past Days :: Motoi Sakuraba (SPC-OPL3 conversion) — Music³: Rockman & Forte :: Museum :: Kirikiri-Chan and others (SPC-OPL3 conversion) — Music⁴: Famicom Tantei Club Part II: Ushiro ni Tatsu Shōjo :: Dean’s Room :: Kenji Yamamoto (SPC-OPL3 conversion), original composition: Bach's Invention № 15 — Music⁵: Aryol :: Arrest :: Kyohei Sada (SPC-OPL3 conversion) — Music⁶: Ren & Stimpy Show : Fire Dogs :: Main Theme :: Martin Gwynn Jones and others (SPC-OPL3 conversion) — Music⁷: Aryol :: Warmup :: Kyohei Sada (SPC-OPL3 conversion) — Music⁸: Energy Breaker :: Golden-Colored Wind :: Yukio Nakajima (SPC-OPL3 conversion) — Music⁹: Wonder Project J :: House :: Akihiko Mori (SPC-OPL3 conversion) — SFX: Mostly from YouTube Audio Library. Some are recorded from video games like The Guardian Legend, Lunar Ball, and Super Mario All-Stars. ¹ 00:37, ² 02:46 & 39:26, ³ 10:10, ⁴ 16:06, ⁵ 27:18, ⁶ 37:20, ⁷ 38:58 & 45:58, ⁸ 49:00, ⁹ 50:40 My links: Twitter: https://twitter.com/RealBisqwit Liberapay: https://liberapay.com/Bisqwit Steady: https://steadyhq.com/en/bisqwit Patreon: https://patreon.com/Bisqwit (Other options at https://bisqwit.iki.fi/donate.html) Twitch: https://twitch.tv/RealBisqwit Homepage: https://iki.fi/bisqwit/ You can contribute subtitles: https://www.youtube.com/timedtext_video?ref=share&v=eF9qWbuQLuw or to any of my videos: https://www.youtube.com/timedtext_cs_panel?tab=2&c=UCKTehwyGCKF-b2wo0RKwrcg ---Rant--- [9:35 PM] Bisqwit: Now uploading to YouTube. Within about 24 hours I will know if the rogue AI at YouTube slams the “limited or no advertising" stamp into it, or not. Actually, I only know if it does so *when* it does it. Then, I need to wait an additional 25 hours for YouTube staff to manually review it and clear the flag. If the flag does not appear, then it is possible that the bot just has not scanned it yet and I need to wait longer. Premature publication could mean that the bot will mark it after it has already been published, and then I will not receive any revenue for the first spike of views. It used to be 18 hours (since uploading that the bot does its evil deeds), but nowadays YT recommends waiting just 3 hours. We will see, we will see. #Bisqwit #Compiler #Tutorial
Views: 82513 Bisqwit
SIMD optimization in JVM compiler - part1
 
01:02
JavaOne2015 submission
Views: 130 Jan Civlin
Compiler Options
 
01:19
Compiler Options Tutorial - AndeSight MCU Version
Views: 602 andescore968
Analysing Compiler Optimization Effectiveness on Adapteva Epiphany, ARM and XMOS platforms
 
05:56
http://jpallister.com/wiki http://ww.cs.bris.ac.uk/Research/Micro http://kck.st/PtAZ9O http://www.adapteva.com Energy efficiency is the highest priority for modern software-hardware co-design. The potential for compiler options to impact on power consumption of running programs has often been discussed. However there has never been a comprehensive analysis of the magnitude of that impact, or how it varies between processor architectures and compilers. Our presentation will describe a project we undertook during the Summer of 2012 at the University of Bristol Department of Computer Science and funded by Embecosm, to explore the effect of compiler options on energy consumption of compiled programs. We used an innovative technique to examine the energy consumption of 10 benchmarks when compiled with 87 optimizations performed by GCC and run on five different embedded platforms. Hardware power measurements on each platform were taken to ensure all architectural effects on the energy were captured. A fractional factorial design was used to separate the effects of each optimization and account for interactions between optimizations. The use of this technique, not commonly used in computer science, has made it feasible to analyse 2^87 possible combinations of optimization over the short period of this project. We found that in the majority of cases execution time and energy consumption were highly correlated, but the effect a particular optimization may have is non-trivial due to its interactions with other optimizations. We also found that the structure of the benchmark had a larger effect than the platform on whether the optimization had an impact on energy consumption. No one optimization is universally positive for energy consumption, but for each benchmark and processor architecture we were able to find the optimization with the main effect on power consumption. There is clearly scope for further work on selecting the optimizations that are most beneficial for an individual program. Our presentation will discuss techniques that can potentially achieve this goal, and are the potential subjects of future research. This research was unusual, in that it was funded as a completely open project. A wiki detailed progress from week to week, the relevant open source communities were kept regularly informed, and the results will be published in open access journals.
Views: 1431 jampallister
Optimize HPC across platforms - Vectorization, Why, When, How...
 
17:02
Optimize HPC on any platform - Application profiling and vectorization to maximize performance on modern processors High performance computing (HPC) applications implement complex scientific models that will require many thousands of calculations to be performed during a realistic simulation. The advanced processing capability of modern CPUs are very well suited to this type of operation. In particular, the use of vector (or Single Instruction Multiple Data) based instructions in an application will help to fully exploit hardware processing capability. It is therefore important to understand how well your application is making use of vectorization. In this webinar, Phil Ridley (Field Application Engineer at Arm), will demonstrate how — by focusing on vectorization — developers can help maximize application use of a CPU's vectorization capability on HPC systems. Topics covered include: • What is vectorization and why it is important for HPC applications • How to identify which regions within my application are utilizing vectorization • How to identify any regions that are not utilizing vectorization and how this might affect overall performance • An introduction to using Arm’s HPC tools for helping to analyze and optimize an application.
Views: 230 Arm
SPR-KKR (intel compiler, openmpi)
 
06:07
Attention ! Please, check intelmpi and openmpi. make.inc --------- ############################################################################### # Here the common makefile starts which does depend on the OS #### ############################################################################### # # FC: compiler name and common options e.g. f77 -c # LINK: linker name and common options e.g. g77 -shared # FFLAGS: optimization e.g. -O3 # OP0: force nooptimisation for some routiens e.g. -O0 # VERSION: additional string for executable e.g. 6.3.0 # LIB: library names e.g. -L/usr/lib -latlas -lblas -llapack # (lapack and blas libraries are needed) # BUILD_TYPE: string "debug" switches on debugging options # (NOTE: you may call, e.g. "make scf BUILD_TYPE=debug" # to produce executable with debugging flags from command line) # BIN: directory for executables # INCLUDE: directory for include files # (NOTE: directory with mpi include files has to be properly set # even for sequential executable) ############################################################################### BUILD_TYPE ?= #BUILD_TYPE := debug VERSION = 6.3 ifeq ($(BUILD_TYPE), debug) VERSION := $(VERSION)$(BUILD_TYPE) endif BIN = . #BIN=~/bin #BIN=/tmp/$(USER) #LIB = -lblas -llapack #LIB = $(LIB_MKL) youtu LIB = ${MKLROOT}/lib/intel64/libmkl_blas95_lp64.a ${MKLROOT}/lib/intel64/libmkl_lapack95_lp64.a -Wl,--start-group ${MKLROOT}/lib/intel64/libmkl_intel_lp64.a ${MKLROOT}/lib/intel64/libmkl_core.a ${MKLROOT}/lib/intel64/libmkl_intel_thread.a -Wl,--end-group -lpthread -lm -ldl LIBMPI = ${MKLROOT}/lib/intel64/libmkl_blas95_lp64.a ${MKLROOT}/lib/intel64/libmkl_lapack95_lp64.a ${MKLROOT}/lib/intel64/libmkl_scalapack_lp64.a -Wl,--start-group ${MKLROOT}/lib/intel64/libmkl_intel_lp64.a ${MKLROOT}/lib/intel64/libmkl_core.a ${MKLROOT}/lib/intel64/libmkl_intel_thread.a ${MKLROOT}/lib/intel64/libmkl_blacs_openmpi_lp64.a -Wl,--end-group -lpthread -lm -ldl # Include mpif.h #INCLUDE = -I/usr/lib/openmpi/include # openmpi-1.10.3 (./configure -prefix=$HOME/openmpi CXX=icpc CC=icc FC=ifort) INCLUDE = -qopenmp -I${HOME}/openmpi/include OP0 = ifeq ($(BUILD_TYPE), debug) # FFLAGS = -O0 -g # FFLAGS = -O0 -g -Wall -fbounds-check -fbacktrace FFLAGS = -O0 -check all -traceback -fpe0 -g -fp-stack-check -ftrapuv -CU ### for ifort else # FFLAGS = -O2 FFLAGS = -O2 -axSSE4.2 -diag-disable remark ### for ifort endif FC = mpif90 -c $(FFLAGS) $(INCLUDE) LINK = mpif90 $(FFLAGS) $(INCLUDE) MPI=MPI --------- ■ SPRKKR 6.3 (Intel compiler 2016) 1) unpack cp $HOME/Downloads/sprkkr6.3*.tgz ./sprkkr cd sprkkr tar -zxvf sprkkr6.3*.tgz 2) cp make.inc_example make.inc 3) gedit make.inc LIB = ${MKLROOT}/lib/intel64/libmkl_blas95_lp64.a ${MKLROOT}/lib/intel64/libmkl_lapack95_lp64.a -Wl,--start-group ${MKLROOT}/lib/intel64/libmkl_intel_lp64.a ${MKLROOT}/lib/intel64/libmkl_core.a ${MKLROOT}/lib/intel64/libmkl_intel_thread.a -Wl,--end-group -lpthread -lm -ldl #LIB = $(LIB_MKL) LIBMPI = ${MKLROOT}/lib/intel64/libmkl_blas95_lp64.a ${MKLROOT}/lib/intel64/libmkl_lapack95_lp64.a ${MKLROOT}/lib/intel64/libmkl_scalapack_lp64.a -Wl,--start-group ${MKLROOT}/lib/intel64/libmkl_intel_lp64.a ${MKLROOT}/lib/intel64/libmkl_core.a ${MKLROOT}/lib/intel64/libmkl_intel_thread.a ${MKLROOT}/lib/intel64/libmkl_blacs_openmpi_lp64.a -Wl,--end-group -lpthread -lm -ldl INCLUDE = -qopenmp -I${MKLROOT}/include/intel64/lp64 -I${MKLROOT}/include FFLAGS = -O2 -axAVX,SSE4.2,SSE4.1,SSE3,SSSE3,SSE2 \ -diag-disable remark ### for ifort FC = mpiifort -c $(FFLAGS) $(INCLUDE) LINK = mpiifort $(FFLAGS) $(INCLUDE) 4) make scfmpi(single type: make scf ) mpirun -n 4 kkrscf6.3MPI *.inp (symbol: larger than) OUTPUT 5) compiling a) make all gen, scf, embgen, embscf b) make allmpi scfmpi, embscfmpi, specmpi c) Makefile make genmpi, make embscfmpi, make chi make opm, make opmmpi, make spec ※ recompile: make clean Usage 1) cif2cell -p sprkkr -f case.f 2) xband 3) DIRECTORIES 4) SELECT/MODIFY case.sys 5) SPR-KKR * MKL link /opt/intel/documentation_2016/en/mkl/ps2016/get_started.htm file:///opt/intel/documentation_2016/en/mkl/common/mkl_link_line_advisor.htm
Update on Modula-2 - GNU Tools Cauldron 2018
 
49:10
Presented by Gaius Mulley at GNU Tools Cauldron 2018 GNU Modula-2 has been grafted onto the trunc, 8.0.1, 6.4.0, 5.4.0, 4.7.4 and 4.1.2 releases of gcc. Several new options have been introduced, most notably, -fm2-g, -fwholevalue, -ffloatvalue and -fm2-plugin. The option -fm2-g will guarantee an instruction for every statement compiled. Integer arithmetic overflow detection for (subtract, addition, negation, multiply, assignment operators, for all ordinal operands and sub-range types. (-fsoft-check-all) and (-fwholevalue) is complete. Detection of a NaN after all floating point arithmetic operations is also available via -ffloatvalue. The new plugin for Modula-2 exploits the optimisation and data flow analysis to provide enhanced semantic checking. Semantic compile time checking has been considerably enhanced by the new plugin which detects whether the initial basic block in any reachable procedure contains a runtime violation (a call to the runtime error library). This works well as the runtime error library functions take source file, line, column as parameters. Thus this information will survive any optimisation and therefore data flow analysis coupled with code transformation optimisations can be usefully leveraged towards gaining better semantic errors.
Views: 130 Embecosm
Compiling C programs with gcc
 
05:43
In cs107, we will primarily be using Makefiles to compile our code, but you should know how to use gcc (the GNU Compiler Collection) to compile a C program independently. We will use three primary flags in cs107: -g : embed debugging information into the program so gdb will give us good information. -Og : compile with gdb in mind, so it leaves in variable information and doesn't optimize out too many variables. -std=gnu99 : the flavor of C we will be using for cs107.
Views: 1054 Chris Gregg
Set compiler options on a file or set of files
 
02:28
It is possible to set file specific compiler options. For example you can change the optimization level used on a file to be different than what is used for the rest of the files in your Code Composer Studio project.
Views: 2394 Code Composer
CppCon 2017: Matt Godbolt “What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid”
 
01:15:46
http://CppCon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017 — In 2012, Matt and a colleague were arguing whether it was efficient to use the then-new-fangled range for. During the discussion a bash script was written to quickly compile C++ source and dump the assembly. Five years later and that script has grown into a website relied on by many to quickly see the code their compiler emits, to compare different compilers' code generation and behaviour, to quickly prototype and share code, and investigate the effect of optimization flags. In this talk Matt will not only show you how easy (and fun!) it is to understand the assembly code generated by your compiler, but also how important it can be. He'll explain how he uses Compiler Explorer in his day job programming low-latency trading systems, and show some real-world examples. He'll demystify assembly code and give you the tools to understand and appreciate how hard your compiler works for you. He'll also talk a little about how Compiler Explorer works behind the scenes, how it is maintained and deployed, and share some stories about how it has changed over the years. By the end of this session you'll be itching to take your favourite code snippets and start exploring what your compiler does with them. — Matt Godbolt: DRW, Senior Software Engineer Matt Godbolt is a software engineer with trading firm DRW, and the creator of the Compiler Explorer website. He is passionate about writing efficient code. He has previously worked at on mobile apps at Google, run his own C++ tools company and spent more than a decade making console games. When he's not hacking on Compiler Explorer, Matt enjoys writing emulators for old 8-bit computer hardware. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 55112 CppCon
Turning on compiler optimization
 
01:33
See how to turn on the optimizer in the Code Composer Studio compiler and set the optimization level.
Views: 2657 Code Composer
Resurrection Remix ROM Kitkat Galaxy Note 3
 
11:24
[ROM][4.4.2][ hlte-Unify] [SaberMod 4.10 ] Resurrection Remix® 4.4.2 KitKat Included Main Features: OPTIMIZATIONS * OPTIMIZATIONS Over 30+ patch to get this rom rolling on strict-Aliasing SaberMod 4.8.3 toolchain loaded on Rom & Linaro Kernel -O3 (highest GCC optimization level) Strict-aliasing enabled Memory Optimized Enabled Halo Active display Lockscreen Notifications Application side bar Omniswitch Notification panel tweaks Tiles style Music Toggle Pitch Black UI Mode Camera mods ListView Animations Custom system animations Custom progress bar Screen recorder Hardware buttons and navbar options Status bar traffic monitor Battery bar options CRT animations SB Brightness slider Expanded desktop Profiles Performance controller Flip tiles Theme chooser Keyboard features Lockscreen see blur and reduce slider Show Wi-Fi name Headset action Low battery warning Lock clock widget Privacy guard Permission management Power sounds Share ROM Battery mods Changelog Lockscreen options and targets Center Clock/No clock/Right Clock AM/PM,date and colors New Wallpaper app Nova/Stock launcher included AND MORE... XDA (more info & download): http://forum.xda-developers.com/showthread.php?t=2709775
Views: 7829 DinamicaMedia
For HFT, Matlab options for Coder toolbox and Compiler with GPU and CUDA
 
03:56
http://quantlabs.net/membership.htm
Views: 205 Bryan Downing
CppCon 2015: Chandler Carruth "Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!"
 
01:29:54
http://www.Cppcon.org — A primary use case for C++ is low latency, low overhead, high performance code. But C++ does not give you these things for free, it gives you the tools to control these things and achieve them where needed. How do you realize this potential of the language? How do you tune your C++ code and achieve the necessary performance metrics? This talk will walk through the process of tuning C++ code from benchmarking to performance analysis. It will focus on small scale performance problems ranging from loop kernels to data structures and algorithms. It will show you how to write benchmarks that effectively measure different aspects of performance even in the face of advanced compiler optimizations and bedeviling modern CPUs. It will also show how to analyze the performance of your benchmark, understand its behavior as well as the CPUs behavior, and use a wide array of tools available to isolate and pinpoint performance problems. The tools and some processor details will be Linux and x86 specific, but the techniques and concepts should be broadly applicable. -- Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all knowledge of the contents of his Master’s thesis. He is regularly found drinking Cherry Coke Zero in the daytime and pontificating over a single malt scotch in the evening. -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 87686 CppCon
Minor optimization level 10
 
00:06
Views: 2 xRay
Stochastic Optimization for x86 Binaries
 
01:03:55
Google Tech Talks January 12, 2015 (more info below) ABSTRACT The optimization of short sequences of loop-free fixed-point x86_64 code sequences is an important problem in high-performance computing. Unfortunately, the competing constraints of transformation correctness and performance improvement often force even special purpose compilers to produce sub-optimal code. We show that by encoding these constraints as terms in a cost function, and using a Markov Chain Monte Carlo sampler to rapidly explore the space of all possible programs, we are able to generate aggressively optimized versions of a given target program. Beginning from binaries compiled by gcc -O0, we are able to produce provably correct code sequences that either match or outperform the code produced by gcc -O3, and in some cases expert hand-written assembly. Because most high-performance applications contain floating-point computations, we extend our technique to this domain and show a novel approach to trading full floating-point precision for further increases in performance. We demonstrate the ability to generate reduced precision implementations of Intel's handwritten C numerics library that are up to six times faster than the original code, and achieve end-to-end speedups of over 30% on a direct numeric simulation and a ray tracer. Because optimizations that contain floating-point computations are not amenable to formal verification using the state of the art, we present a technique for characterizing maximum error and providing strong evidence for correctness. Publication list: http://cs.stanford.edu/people/eschkufz/ Github: https://github.com/eschkufz/stoke-release About the speaker Eric Schkufza is a postdoctoral scholar at Stanford University working with professor Alex Aiken. He graduated from Stanford University with a PhD in computer science in June 2014. He is interested in applying stochastic search techniques to the design of optimizing compilers.
Views: 12690 GoogleTechTalks
CppCon 2017: Dmitry Panin “Practical Techniques for Improving C++ Build Times”
 
55:52
http://CppCon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017 — Slow builds block all C++ developers from the work being done. At Facebook we have a huge codebase, where the time spent compiling C++ sources grows significantly faster than the size of the repository. In this talk we will share our practical experience optimizing build times, in some cases from several hours to just a few minutes. The majority of the techniques are open sourced or generic and can be immediately applied to your codebase. Facebook strives to squeeze build speed out of everything: starting from a distributed build system, through the compiler toolchain and ending with code itself. We will dive into different strategies of calculating cache keys, potential caching traps and approaches to improve cache efficiency. We tune the compiler, specifically with compilation flags, profile data and link time options. We will talk about the benchmarks we use to track improvements and detect regressions and what challenges we face there. Finally, you will learn about our unsuccessful approaches with an explanation of why they didn't work out for us. — Dmitry Panin: Facebook, Software Engineer Dmitry is a software engineer at Facebook working in Ads Infrastructure Team. He has been contributing to efficiency, scalability and reliability of C++ backend services responsible for ads delivery. He is currently hacking on Facebook's build infrastructure and C++ codebase itself with the goal to improve build speed. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 4472 CppCon
MPLAB® XC Compiler Optimizations Webinar
 
05:31
This webinar provides an overview of optimizations provided by the MPLAB XC C compilers. It will help you select a minimal set of optimizations, which allow projects to be easily debugged, or enable them all and have the compiler spend more time improving the performance of your code. http://www.microchip.com/compilers
C++ Weekly - Ep 83 - Installing Compiler Explorer
 
06:03
Come to my `constexpr` class at C++ On Sea: https://cpponsea.uk/sessions/applied-constexpr.html Support these videos: https://www.patreon.com/lefticus Learning C++ Best Practices: http://shop.oreilly.com/product/0636920049814.do Inheritance and Polymorphism with C++: http://shop.oreilly.com/product/0636920052166.do Follow me on twitter: https://twitter.com/lefticus Source:
Views: 5590 Jason Turner
WIEN2k (gfortran + gcc + Netlib{download center} + OpenMP)
 
12:29
WIEN2k (gfortran + gcc + Netlib + OpenMP) (Optimize: SSE4.2) sudo apt-get install csh sudo apt-get install tk sudo apt-get install gfortran sudo apt-get install build-essential sudo apt-get install libblas-dev sudo apt-get install liblapack-dev 1) mkdir WIEN2k_14 2) cd WIEN2k_14 3) cp WIEN2k_14.tar . 4) tar -xvf WIEN2k_14.tar 5) gunzip *.gz 6) chmod +x ./expand_lapw 7) ./expand_lapw 8) ./siteconfig_lapw 9) V gfortran + gotolib 10) gfortran, gcc 11) O Compiler options: -ffree-form -O2 -ffree-line-length-none -msse4.2 -m64 L Linker Flags: $(FOPT) -L../SRC_lib P Preprocessor flags '-DParallel' R R_LIB (LAPACK+BLAS): -llapack_lapw -lblas_lapw -lblas -llapack -fopenmp 12) ./userconfig_lapw 13) bash 14) w2web
4. wxWidgets makefile options, useful to know when building wxWidgets from source
 
00:58
Demonstrates makefile build options within the NuGet wxWidgets project properties. Demonstrates building wxWidgets without Unicode, and "full optimization" via these options: UNICODE=0 CPPFLAGS=/Ox (this is just an example, you don't have to build with those options) Playlist: https://www.youtube.com/watch?v=IaqXi6AYQJs&list=PL9dSV0BKhF3Y_ZfjgX29qNLVR9v9OGv58 Wiki: https://wiki.wxwidgets.org/Microsoft_Visual_C%2B%2B_NuGet Music by Roberto Billi: Roberto Billi - Vita in controtempo http://freemusicarchive.org/music/Roberto_Billi/
Views: 146 Andrew Smart
CppCon 2018: Nir Friedman “Understanding Optimizers: Helping the Compiler Help You”
 
01:04:03
http://CppCon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018 — Optimizing compilers can seem rather fickle: sometimes they do something very sophisticated that surprises us, other times they fail to perform an optimization we assumed they would. By understanding the limits on their knowledge, and the constraints in their output, we can much more reliably predict when certain kinds of optimizations can occur. This, in turn, allows our designs to be informed by being friendly to the optimizer. This talk will discuss concepts fundamental to understanding optimization such as the role of static types, basic blocks, and correctness of emitted code. It will also go through many examples: where inlining does and doesn't occur and why, const propagation, branch pruning, utilizing inferred information/values, the roles of const and value vs reference semantics, etc. It will also show how to help the compiler: writing code in different ways which encourages different optimization strategies. — Nir Friedman Quantitative Developer, Tower Research Capital After completing a PhD in physics, Nir started working doing C++ in low latency and high frequency trading. He's interested in the challenges of writing robust code at scale, and highly configurable code that minimizes performance trade-offs. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 6801 CppCon
GNU Cauldron 2012, Prague, talk5
 
33:41
Identifying compiler options to minimize energy consumption by embedded programs Presenter: Jeremy Bennett During this summer, Embecosm will be running a joint project with Bristol University Department of Computer Science to look at the impact of compiler options on energy consumption by programs on embedded processors. Many people have opinions on this, but it transpires there is very little hard data. Bristol University's equipment can measure the power consumed by a processor in great detail and to fine time resolution. We will test a representative range of programs (suggestions will be solicited from the audience) with a wide range of compiler options. We will use a number of different processors (XMOS, ARM) as well as different processors in the same family (ARM). We will also compare GCC to LLVM. The results will be published in an open access journal to provide a baseline data set for future research. One channel we wish to pursue subsequently is use of MILEPOST technology to automatically select the best low energy options when compiling programs. The project, starting on 9 July, will be led by Jeremy Bennett (Embecosm) and Simon Hollis (Bristol University), with the work carried out by James Pallister of Embecosm, who will then return to Bristol University for a 3-year PhD in this field. The purpose of this talk is to solicit views from the wider GCC community at the start of this project, particularly with regard to the features of GCC that are most likely to yield benefits and should thus be explored. We look forward to presenting the results at next year's meeting.
Views: 95 ITIaKAM
CppCon 2017: Charles Bailey “Enough x86 Assembly to Be Dangerous”
 
30:59
http://CppCon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017 — This tutorial is an introduction to x86 assembly language aimed at C++ programmers of all levels who are interested in what the compiler does with their source code. C++ is a programming language that cares about performance. As with any technology, a deep understanding of C++ is helped by knowledge of the layer below, and this means knowledge of assembly language. Knowing what the compiler does with your source code and the limitations under which it operates can inform how you design and write your C++. We learn how to generate, inspect and interpret the assembly language for your C++ functions and programs. We take a short tour of common assembly instructions and constructs, and discover why extreme caution should be exercised if we are trying to infer performance characteristics from a simple inspection of assembly code. Starting with a simple `operator+` for a user-defined class, we take a look at how interface and implementation choices affect the generated assembly code and observe the effect of copy elisions and related optimizations that compilers commonly perform. — Charles Bailey: Bloomberg LP, Software Engineer Charles Bailey is a software developer at Bloomberg LP. He works in Developer Experience Engineering London, where he consults and advises on all aspects of software development. His previous experience in software development has included roles in many areas, including business intelligence, data warehousing, defence, radar and financial derivatives. In addition to C++, Charles has a keen interest in source control in general and Git in particular. He can be found answering questions on both subjects on Stack Overflow and in person. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 12837 CppCon
Optimizing UE4 for Fortnite: Battle Royale - Part 1 | GDC 2018 | Unreal Engine
 
55:26
Fortnite has served as a development sandbox for UE4, and in this presentation from GDC 2018 we explore the effort involved with taking FNBR from 30fps to 60fps on consoles. Learn more at http://www.UnrealEngine.com
Views: 52547 UnrealEngine
SPR-KKR (compiling example, gfortran + Netlib)
 
02:54
Sorry, this compiling kkrscf and others don't work for MPI calculation in my case. Please, use single core calculation. ############################################################################### # Here the common makefile starts which does depend on the OS #### ############################################################################### # # FC: compiler name and common options e.g. f77 -c # LINK: linker name and common options e.g. g77 -shared # FFLAGS: optimization e.g. -O3 # OP0: force nooptimisation for some routiens e.g. -O0 # VERSION: additional string for executable e.g. 6.3.0 # LIB: library names e.g. -L/usr/lib -latlas -lblas -llapack # (lapack and blas libraries are needed) # BUILD_TYPE: string "debug" switches on debugging options # (NOTE: you may call, e.g. "make scf BUILD_TYPE=debug" # to produce executable with debugging flags from command line) # BIN: directory for executables # INCLUDE: directory for include files # (NOTE: directory with mpi include files has to be properly set # even for sequential executable) ############################################################################### BUILD_TYPE ?= #BUILD_TYPE := debug VERSION = 6.3 ifeq ($(BUILD_TYPE), debug) VERSION := $(VERSION)$(BUILD_TYPE) endif BIN = . #BIN=~/bin #BIN=/tmp/$(USER) LIB = -L/usr/local/lib -llapack -lblas #LIB = $(LIB_MKL) LIBMPI = # Include mpif.h INCLUDE = -I/usr/lib/openmpi/include OP0 = ifeq ($(BUILD_TYPE), debug) # FFLAGS = -O0 -g FFLAGS = -O0 -g -Wall -fbounds-check -fbacktrace # FFLAGS = -O0 -check all -traceback -fpe0 -g -fp-stack-check -ftrapuv -CU ### for ifort else FFLAGS = -O2 -m64 # FFLAGS = -O2 -axSSE4.2 -diag-disable remark ### for ifort endif FC = mpif90.openmpi -c $(FFLAGS) $(INCLUDE) LINK = mpif90.openmpi $(FFLAGS) $(INCLUDE) MPI=MPI
CppCon 2018: Juan Manuel Martinez Caamaño “Easy::Jit: A Just-in-Time compilation library for C++”
 
25:32
http://CppCon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018 — Compiled languages like C++ generally don't have access to Just-in-Time facilities, which limits the range of possible optimizations. The Easy::Jit library introduces an hybrid approach that combines classical ahead of time compilation with user-specified dynamic recompilation of some functions, using runtime information to improve compiled code. Easy::Jit still remains a high level library, aiming to provide a simple way to benefit from Just-in-Time compilation for non-compiler experts. The main abstractions from the library mimics other standard C++ constructs (as std::bind) to ease its adoption. The library is composed of two main parts, the library interface and a compiler plugin. The library interface relies on metaprogramming to generate the appropiate low-level API calls. It also wraps the returned raw function pointers in a high-level object that performs type checking on the parameters of the call. The compiler plugin is in charge of identifying whose bitcode implementation must be exposed at runtime and inject calls to the API that associate function pointers with the bitcode implementations. — Juan Manuel Martinez Caamaño Engineer, Quarkslab Likes LLVM and just-in-time compilation. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 2932 CppCon
QEMU 3.1 - Custom build on PowerMac G5 Quad and Ubuntu Linux 16.04 - Part 2
 
20:01
QEMU 3.1 - Custom build on PowerMac quad core and Ubuntu Mate Linux 16.04 - gcc build G5 optimizations, options and launch parameters to emulate a Sam460ex amiga board and AmigaOS4.1 - speed tests
Views: 83 dino papararo
Android optimizations for ARM by Linaro Engineers
 
17:17
Linaro Engineers present a bunch of optimizations they recently did in Android for ARM. These optimizations are in areas like BIONIC for Cortex C string routines, migrating to GCC 4.9, migrating the external projects to their latest versions, optimizing SQLite, optimizing battery life, also they discuss their progress building Android with CLANG, migrating Android to latest versions and how Linaro is planning to release these optimizations to the Android community through Linaro Android releases and upstream them to respective project repositories. The Android Linaro team's presentations are live and available on Linaro.org LCA14 and on youtube at LinaraOnAir channel - http://www.youtube.com/user/LinaroOnAir
Views: 1336 Charbax
P. Goldsborough “clang-useful: Building useful tools with LLVM and clang for fun and profit"
 
01:22:41
http://cppnow.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/boostcon/cppnow_presentations_2017 — The talk will consist of two parts. The first will be a general overview of the LLVM and clang library infrastructure available for creating custom tools such as static analyzers or source-to-source transformation tools. I will explain the ecosystem of the LLVM and clang tooling environment and outline options, tradeoffs and examples of the different ways of creating a tool (e.g. the difference between creating a plugin vs. a LibTooling executable). I will then go further in depth about how clang represents C++ source code by means of an AST and ways of traversing the AST to look for certain points of interest, e.g. old-style for loops that could be converted to range-based loops, or braces that are indented in Allman instead of One-True-Brace-Style, which could be useful for any company with a style guide it wants to enforce at compile-time rather than on paper or in code-reviews. For the second part, I will then branch out into the two common tasks one might want to perform with a custom-built tool: emitting warnings or errors (for static analysis), and transforming and emitting new code (source-to-source transformations, such as clang-tidy). For each use-case, I will walk through real code that shows how one might approach a simple task in each category. At the end of the talk, I expect listeners to have a basic understanding of the LLVM/clang tooling environment and AST representation. However, most importantly, I expect people to take away knowledge they can take home or to their office and immediately build tools in no time at all that *genuinely* improve their workflow and productivity. This is not a "give a man a fish" talk. This is a "teach a man to fish" talk. — I'm Peter and technically a second year CS student at TU Munich. Practically, I'm a first year student who decided to do a gap year and join the workforce. Since last August I've been doing engineering internships: first Google, then Bloomberg, now Facebook. I currently physically reside in London but really live on GitHub, where I enjoy giving back to and working with the community on a variety of projects. My comfort zone is the intersection of blue skies machine learning research and low-level infrastructure engineering in modern C++. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 13211 BoostCon
CppCon 2018: "Compiling Multi-Million Line C++ Code Bases Effortlessly with the Meson Build System"
 
33:47
http://CppCon.org Jussi Pakkanen "Compiling Multi-Million Line C++ Code Bases Effortlessly with the Meson Build System" — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018 — The Meson build system is a fresh build system designed from the ground up to solve the build problems of today. It is currently seeing growing adoption across many domains and is already being used to build large chunks of most modern Linux distributions. One of the main reasons for this is Meson's heavy focus on usability, meaning that build definitions are both powerful and easy to understand. In this talk we shall look into the design and use of Meson from the ground up going up all the way to projects with millions of lines of code and complex build setups such as code generators and cross compilation. We shall especially examine the problem of dependencies and how Meson solves this age old problem with a composable design that supports both system provided and self built dependencies from the same build definition. Finally we will examine the multi-language support of Meson for easily combining C++ with other languages such as Java, C#, D and Python. — Jussi Pakkanen, Consultant Jussi Pakkanen is the creator and project lead of the Meson build system. He is currently working as a consultant. He has experience in many different fields of computing ranging from slot machines to mail sorting, computer security, Linux desktop development and gaming. His free time has been equally colorful, including things such as comics and illustration, directing movies, music and electronics. When not working on projects he might be found watching bad movies, especially sci-fi and the finest of trash from the 80s. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 6921 CppCon
ARM Cortex Bluepill Board / EmBitz IDE Tutorial (deutsch) Teil #2
 
15:33
Einführung in die Softwareentwicklung mit dem ARM Cortex anhand der Integrierten Entwicklungsumgebung (IDE) "EmBitz 1.1", basierend auf dem GCC Compiler und St-Link V2 Debugger. Nachträgliche Korrekturen: 1: Der Chip ist ein STM32F103 C8 und nicht "CB". Der CB hat 128KB Flash, der C8 zwar auch 128Kb aber nur 64KB "erreichbar", d.h. die oberen 64KB wurden bei der Herstellung deaktiviert, er meldet sich mit C8 bei Abfrage der ID. Ein Override ist nur möglich mit dem OCD Debugger und einem speziellen Debug Script, welches die ID ignoriert. Dann können 128kb beschrieben werden. 2: Unter "Linker Options" in den "Build Options" muss "LTO" (Link Time Optimization) aktiviert werden, damit der Code erheblich kleiner wird und ungenutzte Segmente entfernt werden. Diese Option hat einen erheblichen Einfluss auf die Codegröße!
Views: 369 Kalter Krieger
How To Fix Code Blocks Environment Error Can't find compiler executable in your search path
 
03:17
Fix Code Blocks Environment Error Can't find compiler executable in your search path.How to fix CodeBlocks compiler error 100% working,codeblocks,compiler,environment error,Fix the Environment Error in Code Blocks | Tutorial Lesson 2,If You can't find compiler executable in your search path (gnu gcc compiler.then watch this Technical Hoque Full Tutorial video.As i already mention in My Previous video:How to Install Code Blocks IDE On Windows 10 With C/C++ Compiler,Link:https://youtu.be/pB3k1TxV2To In This Video,How To Fix Code Blocks Environment Error Can't find compiler executable in your search path.You Will learn How to Solve CodeBlocks environment error. (100% Solved)Visit: http://www.technicalhoque.com/ For more YouTube tips and tricks. DOSTO IS VIDEO MEIN HUNMNE DIKHYA HAI KI KAYASE APP CODE::BLOCKS ENVIRONMENT ERROR KO FIX KAR SAKTE HAI,DOSTO SATH MEIN HUNMNEIN DIKHAYA HAI APP CODEBLOCKS MEINKAYSE EK CHOTASA PROGRAM RUN KAR SAKTE HAI. DOSTO AGR APP HUNMSE KOI SOLUTION CHATE HAI ,YA FIR APP KE MAN MEIN IS VIDEO SEW JURE KOI BHI SAWAL HAI2 APP HAMIN COMMENTS PE PUCH SAKTE HAI HUNM 100% JABAB DENGE Click here to Subscribe My Channel: ✔https://goo.gl/VPcw1x Follow me on Soocial Media: ▌►Facebook : https://www.facebook.com/TechnicalHoque/ ▌►Twitter : https://twitter.com/TechnicalHoque ▌►Instagram : https://www.instagram.com/technicalhoque/ ▌►Google+ : https://plus.google.com/+TechnicalHoqueCEH ▌►LinkedIn : https://www.linkedin.com/in/technicalhoque/ ▌►Pinterest : https://in.pinterest.com/technicalhoque/ ▌►Tumbler : https://technicalhoque.tumblr.com/ ▌►Reddit : https://www.reddit.com/user/TechnicalHoque/ ▌►Stumbler : https://www.stumbleupon.com/stumbler/TechnicalHoque Like👍Share🔀 Comment and Subscribe for more cool videos 🎦📱📟💻🔌💽🖲📡 Click Here for Previous Video: How to speed up my computer windows 10,windows 8 and Windows 7 Performance In 2017 HINDI/URDU 🔀https://youtu.be/HZOsEYQ2lXI Uninstall Any Programs/Apps That Won't Uninstall From Windows[ 10,8.1,8 &7] |How to remove program 🔀https://youtu.be/vph_iaZKKc4 Windows 10# Restoring Your Computer with 'Reset This Pc Remove everything' option 🔀https://youtu.be/CTg0DxOZL3o *How to Solve CodeBlocks environment error.,How to Download and install CodeBlocks,codeblocks,compiler,environment error,solve codeblocks environment error,Codeblocks cannot find compiler,code blocks compiler not working,code blocks not building and running,MinGW,Codeblock error,environment error in code block,Toolchain executables,GNU GCC Compiler,compiler,codeblocks Code Blocks Environment Error,Code Blocks Environment Error: Can't find compiler executable in your search path,Can't find compiler executable,Can't find compiler executable in your search path,Fix Code Blocks Environment Error Click here to Check Out all Playlist : Can't Find Compiler Executable In Your Search Path || Solutions For Code blocks compile Can't Find CompilerExecutable In Your Search Path(GNU GCC Compiler) 🔀 https://goo.gl/4wzUiA C++ Code::Blocks error; uses an invalid compiler. Probably the toolchain path,Fix Code Blocks Environment Error Can't find compiler executable in your search path,How to solve code block compiler problem 🔀 https://goo.gl/rc9LbG CODE:BLOCKS ERROR - INVALID COMPLIER ISSUE - HOW TO REPAIR? can't find compiler executable in your search path (gnu gcc compiler 🔀 https://goo.gl/ubLqFd CODE BLOCKS : Compiler Error , BUILD ERROR , ENVIRONMENT Error FIXED | 100% WORKING METHOD How To Fix Codeblocks GNU GCC Compiler! fatal error no such file or directory code blocks,tinyxml error error document empty codeblocks fix 🔀 https://goo.gl/fao3VS How to solve environment error in codeblock,How to solve compiler problem in codeblocks,Code::Blocks Compiling Error 🔀https://goo.gl/3yq74Y Codeblocks NO COMPILA EN WINDOWS - MinGW + Code Blocks Solución en Español 🔀 https://goo.gl/tN2Z2B How to set complier on codeblock 🔀 https://goo.gl/nGxRVt YouTube/Google Adsense Tips,Tricks and Tutorials 🔀 https://goo.gl/yDAwUA YouTube Helpful Tutorials 🔀 https://goo.gl/g8Ubg8 If you have any confusion please let me know through comment! Please Subscribe Our YouTube Channel and You will get Video notification Next time.Here Is The Subscription Link - https://www.youtube.com/c/TechnicalHoqueCEH About: Technical Hoque is an Educational YouTube Channel,Where You Will Find Mobile/Computer Tips and Tricks,search engine optimization,Social Media/Online Marketing,Technology,google,seo,Tutorials,best tech,New Technological Videos in Hindi. Again Thanks For Watching and See You Soon. Technical Hoque YouTube Channel Provides best tech Hindi Technical Videos,Technical Analysis,Technical Difficulties,Technical Interview,Technical Support,Technical Skills,Tech Tips.!Ask me A Question by using hashtag on YouTube or Twitter #Technical Hoque 👍 LIKE ➡ SHARE & SUBSCRIBE I hope you enjoy:)How To Fix Code Blocks Environment Error Can't find compiler executable in your search path Please Subscribe Our YouTube Channel. Thanks!
Views: 8111 HowToHack
LCU14-307: Advanced Toolchain Usage (Part 1)
 
42:21
LCU14-307: Advanced Toolchain Usage (Part 1) --------------------------------------------------- Speaker: Michael Collison, Maxim Kuvyrkov and Will Newton Track: Toolchain Location: Grand Peninsula C, Hyatt Regency San Francisco Airport, Burlingame, CA, United States --------------------------------------------------- ★ Session Summary ★ This set of sessions will go into detail on many toolchain topics and help the attendee get the most out of their toolchain usage.  Topics covered will include: inline assembly Link Time Optimizations (LTO) Feedback Directed Optimizations (FDO) Proper code annotation for:  promoting vectorization avoiding false sharing memory aliasing restrict keyword usage Optimization levels and what they mean Demystifying -march, -mfpu, -mcpu, -mtune, -with-mode Linking options Libatomic usage Debugging binaries compiled with optimizations. --------------------------------------------------- ★ Resources ★ Zerista: http://lcu14.zerista.com/event/member/137754 Google Event:  Presentation:  Video:  Eatherpad: pad.linaro.org/p/lcu14-307 --------------------------------------------------- ★ Event Details ★ Linaro Connect USA - #LCU14 September 15-19th, 2014 Hyatt Regency San Francisco Airport --------------------------------------------------- > http://www.linaro.org > http://connect.linaro.org
Views: 162 Linaro On Air
GCC Vlog #22
 
02:17
PK explains the inner workings of the prayer chain.
CppCon 2017: Nicolai Josuttis “The Nightmare of Move Semantics for Trivial Classes”
 
57:16
http://CppCon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017 — Assume, we implement a very simple class having just multiple string members. Even ordinary application programmer prefer to make it simple and fast. You think you know how to do it? Well beware! It can become a lot harder than you initially might assume. So, let’s look at a trivial class with multiple string members and use live coding to see the effect using different implementation approaches (using constructors passing by value, by reference, by perfect forwarding, or doing more sophisticated tricks). Sooner than later we will fall into the deep darkness of universal/forwarding references, enable_if, type traits, and concepts. — Nicolai Josuttis: IT Communication Nicolai Josuttis (http://www.josuttis.com) is an independent system architect, technical manager, author, and consultant. He designs mid-sized and large software systems for the telecommunications, traffic, finance, and manufacturing industries. He is well known in the programming community because he not only speaks and writes with authority (being the (co-)author of the world-wide best sellers The C++ Standard Library (www.cppstdlib.com), C++ Templates, and SOA in Practice), but is also an innovative presenter, having talked at various conferences and events. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 32119 CppCon
openSUSE Conference 2018 - Why openSUSE
 
24:41
About ideal use case and promoting the gold triangle of openSUSE This talks is split in three topics: 1. openSUSE is not SUSE, it is her sister. There are still too much people outside of open/SUSE world that still confuse the difference and the options they have. This usually leads them to use the wrong distribution for their use cases and thinking that "SUSE" is not working for them. I will describe the current distribution palette and their respective key values and the difference from the SUSE company and openSUSE community. 2. Why should I use openSUSE? I will describe which features from openSUSE make it ideal for which use case. A brief description of what I personally name the gold triangle of openSUSE is mandatory (OBS, openQA, Yast). 3. How to contribute to openSUSE I will describe the workflow to contribute to openSUSE, new packages and maintenance, and how OBS and openQA are involved. This talks is split in three topics: 1. openSUSE is not SUSE, it is her sister. There are still too much people outside of open/SUSE world that still confuse the difference and the options they have. This usually leads them to use the wrong distribution for their use cases and thinking that "SUSE" is not working for them. I will describe the current distribution palette and their respective key values and the difference from the SUSE company and openSUSE community. 2. Why should I use openSUSE? I will describe which features from openSUSE make it ideal for which use case. A brief description of what I personally name the gold triangle of openSUSE is mandatory (OBS, openQA, Yast). 3. How to contribute to openSUSE I will describe the workflow to contribute to openSUSE, new packages and maintenance, and how OBS and openQA are involved. SLindoMansilla
Views: 1122 openSUSE
Getting Started with AVR: Finding Documentation and Turning on an LED (#2)
 
04:49
Hands-on: http://microchipdeveloper.com/8avr:led-on In this video, we will: - Find the device datasheet, Xplained Mini user guide and schematics. - Start a new GCC C Executable project in Atmel Studio 6. - Demonstrate how to efficiently use the datasheet to understand how to configure a pin and turn on an LED. - Set up and use the debugWIRE interface to program the ATmega328P. Follow along with the entire ‘Getting Started with AVR’ series: http://bit.ly/GettingStartedwithAVR Want to explore AVR microcontrollers some more? http://www.atmel.com/products/microcontrollers/avr/ Xplained Mini: http://www.atmel.com/products/microcontrollers/avr/xplained.aspx ATmega328P: http://www.atmel.com/devices/atmega328p.aspx Atmel Studio: http://www.atmel.com/tools/atmelstudio.aspx Stay connected! Embedded Design Blog: http://blog.atmel.com Twitter: http://www.atmel.com/twitter Facebook: http://www.atmel.com/facebook LinkedIn: http://www.atmel.com/linkedin
Views: 55652 Microchip Makes
Atomic’s memory orders, what for? - Frank Birbacher [ACCU 2017]
 
01:27:40
Multithreading in C++ has been used successfully for many years prior to the introduction of C++ 11 to run programs on multi-core hardware. Then the C++ 11 Memory Model for multithreading was introduced with much debate as to its proper application. On the one hand some suggest not to bother with atomics and just use volatile if at all. On the other hand some might be happy to have everything guarded with mutexes. Either side may have been discouraged from looking deeper into the C++ 11 Memory Model, put off by its apparent complexity. The talk will focus on different options of “memory order” when using std::atomic. It’ll explain what the memory order is and what each of the options mean. We’ll take a look at the C++ memory model, sequencing of expressions and synchronization between threads. The talk sheds light on compiler optimizations and generated assembly, examines out-of-order execution in CPUs and possible cache communication between cores. In the end it should be clear what an atomic variable does apart from storing a value.
Views: 2789 ACCU Conference
CppCon 2017: John Regehr “Undefined Behavior in 2017 (part 1 of 2)”
 
49:23
http://CppCon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2017 — Undefined behavior is a clear and present danger for all application code written in C++. The most pressing relevance is to security, but really the issue is one of general software correctness. The fundamental problem lies in the refusal of C++ implementations (in general) to trap or otherwise detect undefined behaviors. Since undefined behaviors are silent errors, many developers have historically misunderstood the issues in play. Since the late 1990s undefined behavior has emerged as a major source of exploitable vulnerabilities in C++ code. This talk will focus on trends in the last few years including (1) increased willingness of compilers to exploit undefined behaviors to break programs in hard-to-understand ways and (2) vastly more sophisticated tooling that we have developed to detect and mitigate undefined behaviors. The current situation is still tenuous: only through rigorous testing and hardening and patching can C++ code be exposed to untrusted inputs, even when this code is created by strong development teams. This talk will focus on what developers can and should do to prevent and mitigate undefined behaviors in code they create or maintain. — John Regehr: University of Utah, Professor John Regehr is a professor of computer science at the University of Utah, USA. His research group creates tools for making software more efficient and correct. For example, one of his projects, Csmith, generates random C programs that have been used to find more than 500 previously unknown bugs in production-quality C compilers. Outside of work John likes to explore the mountains and deserts of Utah with his family. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Views: 6091 CppCon
Episode 4.2 - Automatic Vectorization and Array Notation
 
06:53
Table of Contents: 00:23 - Automatic vectorization feature of the compilers 00:47 - Vectorizing simple code in C 01:01 - Compiler flags for automatic vectorization: -qopt-report -qopt-report-phase:vec 01:17 - Vectorization report 01:30 - Interpreting vectorization report 01:41 - Running vectorized application 01:55 - Porting vectorizable application for MIC architecture 02:04 - Vectorization report for MIC 02:10 - Running vectorized application on MIC 02:16 - Optimization report for automatic vectorization is enables for optimization level -O2 02:27 - Masked vector operations on MIC 02:43 - Limitations of automatic vectorization 02:51 - Only for-loops can be vectorized 03:10 - Memory access must be regular 03:18 - What cannot be vectorized 03:43 - Compiler cannot automagically vectorize your code 04:01 - Summing it up 04:09 - Array notation 04:42 - Operations of slices of arrays 05:18 - Array notation with stride 05:27 - Compiler can vectorize better non-stride array notation than for-loops 05:41 - Operations on entire array with array notation 05:50 - Multidimensional array notation is also supported 05:54 - Fortran array notation 06:05 - Array notation is enabled by default in the Intel C++ compiler 06:15 - Protecting code with __INTEL_COMPILER macro 06:30 - Assumed vector dependence in the next episode
Views: 670 Vadim Karpusenko
QEMU 3.1 - Custom build on PowerMac G5 Quad  and Ubuntu Linux 16.04 - Part 1
 
18:07
QEMU 3.1 - Custom build on PowerMac quad core and Ubuntu Mate Linux 16.04 - gcc build G5 optimizations, options and launch parameters to emulate a Sam460ex amiga board and AmigaOS4.1 - speed tests
Views: 60 dino papararo
2013 Day1P2 Life of Binaries: Compilers
 
03:15
The class materials are available at http://www.OpenSecurityTraining.info/LifeOfBinaries.html Follow us on Twitter for class news @OpenSecTraining. The playlist for this class is here: http://bit.ly/1cdrfel The full quality video can be downloaded at http://archive.org/details/opensecuritytraining Have you ever wondered what happens when a C program is compiled and executed on a system? This three-day class by Xeno Kovah will investigate the life of a binary from birth as C source code to death as a process running in memory being terminated. Topics will include but are not limited to: *Scanning and tokenizing source code. *Parsing a grammar and outputting assembly code. *Different targets for x86 assembly object files generation. (E.g. relocatable vs. position independent code). *Linking object files together to create a well-formed binary. *Detailed description of the Windows PE binary format. *How Windows loads a binary into memory and links it on the fly before executing it. *Detailed description of the Unix/Linux/BSD ELF binary format. Along the way we will discuss the relevance of security at different stages of a binary's life, from how viruses *really* work, to the way which malware "packers" duplicate OS process execution functionality, to the benefit of a security-enhanced OS loader which implements address space layout randomization (ASLR). Lab work will include: *Using the new "Binary Scavenger Hunt" tool which creates randomized PE binaries and asks randomized questions about the material you just learned! *Manipulating compiler options to change the type of assembly which is output *Manipulating linker options to change the structure of binary formats *Reading and understanding PE files with PEView *Using WinDbg to watch the loader resolve imports in an executable *Using Thread Local Storage (TLS) to obfuscate control flow and serve as a basic anti-debug mechanism *Creating a simple example virus for PE *Analyze the changes made to the binary format when a file is packed with UPX *Using the rootkit technique of Import Address Table (IAT) hooking to subvert the integrity of a program's calls to external libraries, allowing processes to be hidden. The prerequisites for this class are a basic understanding of C programming and compilation. This class is recommended for a later class on Rootkits (playlist: http://bit.ly/HLkPVG) as we talk about IAT Hooking, and required for a later class on malware analysis.
Views: 4298 Open SecurityTraining
LCU14-311: Advanced Toolchain Usage (Part 2)
 
55:21
LCU14-311: Advanced Toolchain Usage (Part 2) --------------------------------------------------- Speaker: Michael Collison, Maxim Kuvyrkov and Will Newton Track: Toolchain Location: Grand Peninsula C, Hyatt Regency San Francisco Airport, Burlingame, CA, United States --------------------------------------------------- ★ Session Summary ★ This set of sessions will go into detail on many toolchain topics and help the attendee get the most out of their toolchain usage.  Topics covered will include: inline assembly Link Time Optimizations (LTO) Feedback Directed Optimizations (FDO) Proper code annotation for:  promoting vectorization avoiding false sharing memory aliasing restrict keyword usage Optimization levels and what they mean Demystifying -march, -mfpu, -mcpu, -mtune, -with-mode Linking options Libatomic usage Debugging binaries compiled with optimizations. --------------------------------------------------- ★ Resources ★ Zerista: http://lcu14.zerista.com/event/member/137758 Google Event:  Presentation:  Video:  Eatherpad: pad.linaro.org/p/lcu14-311 --------------------------------------------------- ★ Event Details ★ Linaro Connect USA - #LCU14 September 15-19th, 2014 Hyatt Regency San Francisco Airport --------------------------------------------------- > http://www.linaro.org > http://connect.linaro.org
Views: 104 Linaro On Air

Prednisone hexal 20mg 50mg
Ramtirth brahmi hair oil 200 ml to oz
Cipralex 5 mg beipackzettel
Alli orlistat 60mg reviews on hydroxycut
Remedio velija 60mg of prednisone