search for: shrinking

Hello Guys I am facing a problem using cifs filesytem on centos 4.3 32 bit to connect to remote shares.we have DAS(Dell md1000) connected to a Dell 2950(win 2003 std).let me descibe the proc which i followed to access thi DAS via 2950.. 1) create a normal user account on Dell2950(win 2003) create 3 folders with names mysqhare1,myshare2,myshare3 in the storage area and assign all permissions to

got a centos5.2 web/database server thats on a public coloc, its dmesg fills up with TCP: Treason uncloaked! Peer 82.135.195.32:64905/8032 shrinks window 354477433:354478918. Repaired. TCP: Treason uncloaked! Peer 82.135.195.32:64905/8032 shrinks window 354477433:354478918. Repaired. TCP: Treason uncloaked! Peer 82.135.195.32:64905/8032 shrinks window 354477433:354478918. Repaired. TCP:

Hi, I have an ext3 file system created with -T largefile4 option. Now it is running out of inode but it's only about 10% full. - Is there a way now to increase the number of inode without making a new file system? - If not, I am thinking about shrinking the file system, and then use the free up space to create a new file system with more inodes, and move the data over. Since I am already running out of inode, would I still be able to shrink the file system? Thanks, ... ling

...bitfields. If some bitfields are natural aligned and their num of bits can form a legal integer type that the target supports, it is more efficient to access them directly than doing a large integer load/store plus a series of bit operations. We call such reverse transformation legal type bitfield shrinking. Currently, llvm depends on DAGCombiner to do such shrinking. However, DAGCombiner has the one-basic-block-a-time limitation, so we started to implement a new shrinking optimization in https://reviews.llvm.org/D30416, and initially put it in instcombine, then moved it to CGP because we want to use...

Hi Francis, Thanks for getting back to me. Could you please provide more details about the problems you encounter with those tools and what improvements required to improve compact unwinding format? Most of my experience is in the mid end, but it is still surprising to me that an improved shrink wrap will break that many tools, considering the fact that gcc has a good shrink wrapping pass and

Hi Arnaud, Thanks for following up with that and sorry for the breakage. Couple of comments: MachineLoopInfo *MLI; + RegScavenger *RS; Would it make sense to use a unique_ptr here? That should eliminate the need of having explicit deletes. +; RUN: llc -mtriple=aarch64-linux-gnu -o - %s Add -enable-shrink-wrap=true and a second RUN line with -enable-shrink-wrap=false. Then add check lines

Hi, Sorry for bringing back such an old thread. I am interested in the latest status of the shrink wrapping pass in LLVM. I have found some active work back in 2017 from Francis Visoiu Mistrih and Kit Barton from the following links. However, it seems that all the work suddenly stops and the improvement for the existing shrink wrapping did not make it into the trunk. Is this work abandoned?

Hi Quentin, After shrink-wrapping was enabled as default on AArch64, llc has a seg fault when compiling the attached .ll file on AArch64. My command is llc -mcpu=cortex-a57 bug.ll Best, Haicheng -------------- next part -------------- A non-text attachment was scrubbed... Name: bug.ll Type: application/octet-stream Size: 8983 bytes Desc: not available URL:

Hi Does anyone know if the shrink wrap pass works for ARM architecture? I tried it seems not working. Which architecture shrink warp was originally designed for? Thanks, Yin -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20131030/d2a4e878/attachment.html>

...tural aligned and their num of bits can form a >> legal integer type that the target supports, it is more efficient to >> access them directly than doing a large integer load/store plus a >> series of bit operations. We call such reverse transformation legal >> type bitfield shrinking. Currently, llvm depends on DAGCombiner to do >> such shrinking. >> >> However, DAGCombiner has the one-basic-block-a-time limitation, so we >> started to implement a new shrinking optimization in >> https://reviews.llvm.org/D30416, and initially put it in instcombine,...

Hi all, We've seen several examples recently of performance opportunities on POWER if we can improve the location of save/restore code for callee-saved registers. Both Nemanja and myself have discussed this with several people, and it seems that there are two possibilities for improving this: 1. Extend shrink wrapping to make the analysis of callee-saved registers more precise. 2.

Here is an updated patch for shrink wrapping with: - spills/restores done with stack slot stores/loads - stack adjustment removed - refactoring (but still in need of more) - spill/restore insertion code unified with spill/restore placement code Documentation available here<http://wiki.github.com/jdmdj/llvm-work/shrink-wrapping-work> illustrates shrink wrapping with loops and discusses a

...tural aligned and their num of bits can form a >> legal integer type that the target supports, it is more efficient to >> access them directly than doing a large integer load/store plus a >> series of bit operations. We call such reverse transformation legal >> type bitfield shrinking. Currently, llvm depends on DAGCombiner to do >> such shrinking. >> >> However, DAGCombiner has the one-basic-block-a-time limitation, so we >> started to implement a new shrinking optimization in >> https://reviews.llvm.org/D30416, and initially put it in instcombine,...

I know nothing about this pass, but here are a few comments. > Does anyone know if the shrink wrap pass works for ARM architecture? First, how are you invoking it? Looks to be a command line option, so -mllvm -shrink-wrap should enable it. Assuming you have a Debug build, you can see the debug output using -debug-only=shrink-wrap. > I tried it seems not working. Which architecture

On Mar 13, 2009, at 10:43 AM, John Mosby wrote: > > I started to reduce the traversals, then decided to work on edge > splitting because I believe it may be needed to finish shrink > wrapping. Hmm. I don't think edge splitting would be required for correctness, right? There is always a common predecessor / successor. For the first pass, we should not be shooting to

[Continuing a discussion from IRC so we have a permanent record] We want to shrink a disk image using virt-resize. Shrinking is harder and not really documented. It requires some manual calculations too. Here is the original: $ virt-df -a 209e6911-fe48-4321-900f-928b3400df88 Filesystem 1K-blocks Used Available Use% 209e6911-fe48-4321-900f-928b3400df88:/dev/sda1...

On Mon, Mar 2, 2009 at 10:35 AM, Evan Cheng <echeng at apple.com> wrote: > > On Mar 1, 2009, at 2:57 PM, John Mosby wrote: > > Obviously, all of this applies only when spills are done with push/pop, > which is the case on x86. I used this issue to start looking at generalizing > how spills and restores are handled, before looking too closely at other > targets, and

I did something stupid when setting up a server which is now live. I think I'm stuck. I set up swap on Raid1 which is decidedly non-optimal. I'd prefer 2 independent swap partitions at the same priority. Here is the set up: /dev/sda1 + /dev/sdb1 -> md0 (raid1) md0 -> VolGroup00 VolGroup00 -> VG00LV00(/), VG00LV01(/home), VG00LV02(swap) I've gotten as far as : Turning

Hi John, It looks pretty good. Thanks for working on this. Some comments: 1. Some of the functions that you introduced, e.g. stringifyCSRegSet probably ought to be "static" and ifdef'ed out when NDEBUG is defined. 2. + // DEBUG + if (! MBB->empty() && ! CSRUsed[MBB].intersects(restore)) { + MachineInstr* MI = BeforeI; + DOUT <<

On Feb 26, 2009, at 2:02 PM, John Mosby wrote: > Hello LLVMdev, > > I have been working with LLVM for just over a year now, mainly in > the area of compilation for HDLs like SystemVerilog and SystemC. > Most of this work dealt with translation to LLVM IR, representing > concurrent languages with LLVM and using LLVM analyses and transforms > for compiling onto proprietary