HomeSort by relevance Sort by last modified time
    Searched full:statically (Results 126 - 150 of 1749) sorted by null

1 2 3 4 56 7 8 91011>>

  /system/update_engine/
boot_control_recovery.h 31 // bootloader by linking against it statically. This should only be used in
  /external/ImageMagick/PerlMagick/
README.txt 51 PERL interpreter!) with PerlMagick statically linked (but other libraries
52 linked statically or dynamically according to system linker default),
60 than 'perl' (e.g. 'PerlMagick') and with PerlMagick statically linked
  /external/v8/src/base/
safe_conversions_impl.h 46 // Helper templates to statically determine if our destination type can contain
84 // Signed to unsigned: Dst cannot be statically determined to contain Src.
133 // Dst range is statically determined to contain Src: Nothing to check.
  /prebuilts/go/darwin-x86/src/runtime/
rt0_linux_ppc64le.s 137 // In a statically linked binary, the stack contains argc,
147 // we're statically linked; otherwise we're dynamically
152 // Statically linked
  /prebuilts/go/linux-x86/src/runtime/
rt0_linux_ppc64le.s 137 // In a statically linked binary, the stack contains argc,
147 // we're statically linked; otherwise we're dynamically
152 // Statically linked
  /external/swiftshader/docs/
Reactor.md 31 Just-in-time (JIT) compiled code has the potential to be faster than statically compiled code, through [run-time specialization](http://en.wikipedia.org/wiki/Run-time_algorithm_specialisation). However, this is rarely achieved in practice.
33 Specialization in general is the use of a more optimal routine that is specific for a certain set of conditions. For example when sorting two numbers it is faster to swap them if they are not yet in order, than to call a generic quicksort function. Specialization can be done statically, by explicitly writing each variant or by using metaprogramming to generate multiple variants at static compile time, or dynamically by examining the parameters at run-time and generating a specialized path.
35 Because specialization can be done statically, sometimes aided by metaprogramming, the ability of a JIT-compiler to do it at run-time is often disregarded. Specialized benchmarks show no advantage of JIT code over static code. However, having a specialized benchmark does not take into account that a typical real-world application deals with many unpredictable conditions. Systems can have one core or several dozen cores, and many different ISA extensions. This alone can make it impractical to write fully specialized routines manually, and with the help of metaprogramming it results in code bloat. Worse yet, any non-trivial application has a layered architecture in which lower layers (e.g. framework APIs) know very little or nothing about the usage by higher layers. Various parameters also depend on user input. Run-time specialization can have access to the full context in which each routine executes, and although the optimization contribution of specialization for a single parameter is small, the combined speedup can be huge. As an extreme example, interpreters can execute any kind of program in any language, but by specializing for a specific program you get a compiled version of that program. But you don't need a full-blown language to observe a huge difference between interpretation and specialization through compilation. Most applications process some form of list of commands in an interpreted fashion, and even the series of calls into a framework API can be compiled into a more efficient whole at run-time.
39 Clearly we need a manageable way to benefit from run-time specialization where it would help significantly, while still resorting to static compilation for anything else. A crucial observation is that the developer has expectations about the application's behavior, which is valuable information which can be exploited to choose between static or JIT-compilation. One way to do that is to use an API which JIT-compiles the commands provided by the application developer. An example of this is an advanced DBMS which compiles the query into an optimized sequence of routines, each specialized to the data types involved, the sizes of the CPU caches, etc. Another example is a modern graphics API, which takes shaders (a routine executed per pixel or other element) and a set of parameters which affect their execution, and compiles them into GPU-specific code. However, these examples have a very hard divide between what goes on inside the API and outside. You can't exchange data between the statically compiled outside world and the JIT-compiled routines, unless through the API, and they have very different execution models. In other words they are highly domain specific and not generic ways to exploit run-time specialization in arbitrary code.
41 This is becoming especially problematic for GPUs, as they are now just as programmable as CPUs but you can still only command them through an API. Attempts to disguise this by using a single language, such as C++AMP and SYCL, still have difficulties expressing how data is exchanged, don't actually provide control over the specialization, they have hidden overhead, and they have unpredictable performance characteristics across devices. Meanwhile CPUs gain ever more cores and wider SIMD vector units, but statically compiled languages don't readily exploit this and can't deal with the many code paths required to extract optimal performance. A different language and framework is required.
48 Reactor allows you to create new functions at run-time. Their generation happens in C++, and after materializing them they can be called during the execution of the same C++ program. We call these dynamically generated functions "routines", to discern them from statically compiled functions and methods. Reactor's ```Routine``` class encapsulates a routine. Deleting a Routine object also frees the memory used to store the routine.
305 But now there's a lot of repeated code. It could be made more manageable using macros or templates, but that doesn't help reduce the binary size of the statically compiled code. That's fine when there are only a handful of state conditions to specialize for, but when you have multiple state variables with many possible values each, the total number of combinations can be prohibitive.
  /external/boringssl/src/include/openssl/
thread.h 75 * pull in windows.h. It's statically asserted that this structure is large
85 * ensure that we'll be able to get it. It's statically asserted that this
99 * do that. Instead we statically assert that the size and native alignment of
  /external/llvm/include/llvm/IR/
Dominators.h 81 /// Definition: A block is said to be forward statically reachable if there is
82 /// a path from the entry of the function to the block. A statically reachable
83 /// block may become statically unreachable during optimization.
  /frameworks/base/core/java/android/printservice/
PrintServiceInfo.java 229 * <strong>Statically set from
244 * <strong>Statically set from
259 * <strong>Statically set from
  /prebuilts/clang/host/darwin-x86/clang-3957855/prebuilt_include/llvm/include/llvm/IR/
Dominators.h 99 /// Definition: A block is said to be forward statically reachable if there is
100 /// a path from the entry of the function to the block. A statically reachable
101 /// block may become statically unreachable during optimization.
  /prebuilts/clang/host/darwin-x86/clang-3960126/prebuilt_include/llvm/include/llvm/IR/
Dominators.h 99 /// Definition: A block is said to be forward statically reachable if there is
100 /// a path from the entry of the function to the block. A statically reachable
101 /// block may become statically unreachable during optimization.
  /prebuilts/clang/host/darwin-x86/clang-3977809/prebuilt_include/llvm/include/llvm/IR/
Dominators.h 99 /// Definition: A block is said to be forward statically reachable if there is
100 /// a path from the entry of the function to the block. A statically reachable
101 /// block may become statically unreachable during optimization.
  /prebuilts/clang/host/darwin-x86/clang-4053586/prebuilt_include/llvm/include/llvm/IR/
Dominators.h 99 /// Definition: A block is said to be forward statically reachable if there is
100 /// a path from the entry of the function to the block. A statically reachable
101 /// block may become statically unreachable during optimization.
  /prebuilts/clang/host/linux-x86/clang-3957855/prebuilt_include/llvm/include/llvm/IR/
Dominators.h 99 /// Definition: A block is said to be forward statically reachable if there is
100 /// a path from the entry of the function to the block. A statically reachable
101 /// block may become statically unreachable during optimization.
  /prebuilts/clang/host/linux-x86/clang-3960126/prebuilt_include/llvm/include/llvm/IR/
Dominators.h 99 /// Definition: A block is said to be forward statically reachable if there is
100 /// a path from the entry of the function to the block. A statically reachable
101 /// block may become statically unreachable during optimization.
  /prebuilts/clang/host/linux-x86/clang-3977809/prebuilt_include/llvm/include/llvm/IR/
Dominators.h 99 /// Definition: A block is said to be forward statically reachable if there is
100 /// a path from the entry of the function to the block. A statically reachable
101 /// block may become statically unreachable during optimization.
  /prebuilts/clang/host/linux-x86/clang-4053586/prebuilt_include/llvm/include/llvm/IR/
Dominators.h 99 /// Definition: A block is said to be forward statically reachable if there is
100 /// a path from the entry of the function to the block. A statically reachable
101 /// block may become statically unreachable during optimization.
  /bionic/libc/upstream-netbsd/lib/libc/resolv/
mtctxres.c 105 * statically. When linked dynamically _mtctxres_init() should
  /development/host/windows/usb/api/
SOURCES 29 # Use statically linked atl libraries:
  /development/host/windows/usb/winusb/
SOURCES 29 # Use statically linked atl libraries:
  /development/ndk/platforms/android-9/arch-arm/src/
crtbegin_static.c 59 any executable that is statically-linked with Bionic
  /external/autotest/client/site_tests/platform_ToolchainOptions/
platform_ToolchainOptions.py 221 now_cmd = ("(%s {} | grep -q statically) ||"
230 relro_cmd = ("(%s {} | grep -q statically) ||"
239 pie_cmd = ("(%s {} | grep -q statically) ||"
253 textrel_cmd = ("(%s {} | grep -q statically) ||"
  /external/bison/lib/
vasnprintf.h 52 a statically allocated or stack-allocated buffer, like this:
  /external/clang/test/SemaObjC/
message.m 40 // a statically typed object's class interface isn't in scope! This
  /external/curl/lib/
CMakeLists.txt 101 # Add "_imp" as a suffix before the extension to avoid conflicting with the statically linked "libcurl.lib"

Completed in 2329 milliseconds

1 2 3 4 56 7 8 91011>>