search for: shave

Defaults to disabled --- .gitignore | 2 + acinclude.m4 | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++ configure.ac | 4 +++ shave-libtool.in | 69 +++++++++++++++++++++++++++++++++++++++++++++++ shave.in | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 231 insertions(+), 0 deletions(-) create mode 100644 acinclude.m4 create mode 100644 shave-libtool.in create mode 100644 shave.in d...

Does anyone know if Hastie's gene shaving method is implemented in R Thanks, Aimin

...32" ...>, Requires<[isV2]>; This all works fine, but there is a large number of them which makes maintenance difficult. This also adds to the burden of selection when using 'BuildMI' in the C++ code, as I have to do things like: if (isV1()) BuildMI(..., TII->get(SHAVE::LD32_v1) else if (isV2()) BuildMI(..., TII->get(SHAVE::LD32_v2) What I would like, is for some mechanism that can substitute the version specific mnemonic dynamically (perhaps using a lookup table), and I could reduce the above to just: def LD32 : Instr<... "??MetaMnemonic??...

I've been curious for a while whether SmallVectors have the right speed/memory tradeoff. It would be straightforward to shave off a couple of pointers (1 pointer/4B on 32-bit; 2 pointers/16B on 64-bit) if users could afford to test for small-mode vs. large-mode. The current scheme works out to something like this: ``` template <class T, size_t SmallCapacity> struct SmallVector { T *BeginX, *EndX, *CapacityX; T...

As I’m sure many of you have noticed, I no longer have the time to be a proper code owner for SelectionDAG. In the interest of the project and to keep development running smoothly, I am resigning my code ownership. Justin Bogner has graciously volunteered to take it up. He has a strong history of LLVM contributions, a demonstrated commitment to good community development practices, and has

...l" does not exist. Call Stack (most recent call first): CMakeLists.txt:937 (add_lit_target) Any ideas on what might be causing this? My invocation of CMake is as follows: cmake -Wno-dev -G "Visual Studio 14 2015 Win64" ../llvm \ "-DLLVM_TARGETS_TO_BUILD=SHAVE;X86 " \ -DLLVM_DEFAULT_TARGET_TRIPLE=shave \ -DLIBCLANG_BUILD_STATIC=1 \ -DLLVM_ENABLE_ZLIB=0 \ -DENABLE_SHARED=0 Thanks, MartinO -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/...

...r<... “LD.32” ...>, Requires<[isV2]>; This all works fine, but there is a large number of them which makes maintenance difficult. This also adds to the burden of selection when using ‘BuildMI’ in the C++ code, as I have to do things like: if (isV1()) BuildMI(..., TII->get(SHAVE::LD32_v1) else if (isV2()) BuildMI(..., TII->get(SHAVE::LD32_v2) What I would like, is for some mechanism that can substitute the version specific mnemonic dynamically (perhaps using a lookup table), and I could reduce the above to just: def LD32 : Instr<... “??MetaMnemonic??” ......

...t; Call Stack (most recent call first): > CMakeLists.txt:937 (add_lit_target) > > Any ideas on what might be causing this? My invocation of CMake is as follows: > > cmake -Wno-dev -G "Visual Studio 14 2015 Win64" ../llvm \ > "-DLLVM_TARGETS_TO_BUILD=SHAVE;X86 " \ > -DLLVM_DEFAULT_TARGET_TRIPLE=shave \ > -DLIBCLANG_BUILD_STATIC=1 \ > -DLLVM_ENABLE_ZLIB=0 \ > -DENABLE_SHARED=0 > > Thanks, > > MartinO > > _______________________________________________ > LLVM Developers mailing li...

...but I thought I'd ask to see what's out there. Basically, I have a 2-dimensional data set and I want to identify local peaks in the data, while ignoring "trivial" peaks. My naive algorithm first identifies every peak and valley (point of inflection change in the graph), then shaves off shallow peaks and valleys based on an arbitrary depth parameter, then returns whatever is left. This produces decent results, but, again, I'd like to know what other implementations are available. (* source available on request)

...win. I don't know how realistic it is to model the loop buffer in the register allocator, but this would a very interesting thing to try to optimize for in a later pass. If an inner loop "almost" fits, then it would probably be worth heroic effort to try to reduce the size of it to shave off a few bytes. -Chris

...ues in X[,1] are IN Y[,2], which is useful in removing unnecessary values from X[,1]. But it does not tell me exactly where they match. which(X[,1] %in% Y[,2]) does but it only matches on the first instance. This is the slowest part of the script I'm working on--if I could improve it I could shave off some serious operating time. Any pointers? Regards, Pete

...nised type). Unfortunately I haven't got my head around the innards of TableGen yet, so I am asking if anyone has any advice on how to add a new vector data type to TableGen? The main reason I need this is that OpenCL supports vectors with 16 elements for all supported scalar types, and the SHAVE processor does support FP16 (aka 'half') data types. Although we don't natively support 16 x FP16, I would like to optimise how values of this type are passed and returned; so any advice is appreciated. I have the same problem with 'v16f64', although this type does not occu...

> On 2014 Oct 16, at 22:09, Sean Silva <chisophugis at gmail.com> wrote: > > Dig into this first! This isn't the right forum for digging into ld64. > In the OP you are talking about essentially a pure "optimization" (in the programmer-wisdom "beware of it" sense), to "save" 2GB of peak memory. But from your analysis it's not clear that

I''ve been having a mess of a time using this module, which stinks because its behavior is EXACTLY what I am looking for... whenever I bootstrap new rabbitMQ nodes I want to add them to our HAProxy instance. Here''s my relevant site.pp entries: node /^rabbit.*/ inherits basenode { @@haproxy::balancermember { $fqdn: listening_service => ''messaging00'',

...; wrote: >> >> >> >> On Jun 21, 2018, at 9:52 AM, Duncan P. N. Exon Smith via llvm-dev <llvm-dev at lists.llvm.org> wrote: >> >> I've been curious for a while whether SmallVectors have the right speed/memory tradeoff. It would be straightforward to shave off a couple of pointers (1 pointer/4B on 32-bit; 2 pointers/16B on 64-bit) if users could afford to test for small-mode vs. large-mode. > > Something like this could definitely work, but most smallvectors are on the stack. They are intentionally used when sizeof(smallvector) isn’t importan...

I am trying to implement stack probes for our SHAVE target, and I see that the compiler injects references to '__stack_chk_guard' and '__stack_chk_fail'. The code that gets generated is horribly wrong, but in order to understand how to fix it I was wondering if there is a clear statement of how the mechanism is supposed to work?...

On Sat, Feb 18, 2012 at 3:20 AM, Chris Lattner <clattner at apple.com> wrote: > My advise is to check in when you have to make forward progress. If > people want to reshave your yak into another hairdo, then then can do that > at some later time. No reason to block your progress as long as the API is > good. I was trying to give feedback on the API, and specifically suggest an alternative that might be both easier to use, and naturally dovetail with an upcomi...

This shaves about 20% off the compile time for the daemon subdirectory. See also: https://rwmj.wordpress.com/2015/09/30/make-and-queuing-theory/#content --- daemon/Makefile.am | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/daemon/Makefile.am b/daemon/Makefile.am index 1d29a0f..4ea3c...

...e residual is iteratively partitioned into 2^min# .. 2^max# pieces, each with its own Rice parameter. Higher values of max# yield diminishing returns. The most bang for the buck is usually with <span class="argument">-r 2,2</span> (more for higher block sizes). This usually shaves off about 1.5%. The technique tends to peak out about when blocksize/(2^n)=128. Use <span class="argument">-r 0,16</span> to force the highest degree of optimization. + By default the encoder uses a single Rice parameter for the subframe's entire residual. With thi...

...require ''rspec'' on my machine was taking close to half a second. That''s not a huge amount of time, but it is still the single slowest part of my test suite. It boils down to Ruby 1.9''s rather slow require. I''m using 1.9.3, but I''d still like to shave off some of the require time. As an experiment, I went into rspec-core and rspec-expectations (the two biggest offenders) and replaced all require calls with require_relative. The benefits are actually quite impressive: rspec-core: before: 0.16s after: 0.10s rspec-expectations: before: 0.16s aft...