search for: unfolded

I have gone ahead and implemented the unfold distance option as mentioned in the source. the patch is here http://home.comcast.net/~moppsy/compiz/cube-unfold-distance.patch

...looking for a loop unfolding procedure implemented in LLVM that helps to transform a while-loop to n-layer If-statements. The transformation should be on IR, although the example below is illustrated on the source level. original loop: * WHILE (condition) DO action ENDWHILE* Expected unfolded loop (2-layer): * IF (condition) THEN* * action* * IF (condition) THEN* * action* * WHILE (condition) DO action ENDWHILE * * ENDIF* * ENDIF* (I thought such transformation is somewhat...

Here's the code and compilation steps: #include <stdint.h> typedef unsigned int uint128_t __attribute__((mode(TI))); typedef struct{ uint64_t l[5]; } s; void f(s * restrict r, const s * restrict x, const s * restrict y) { uint128_t t[5] = {0, 0, 0, 0, 0}; #define BODY(i,j) { int i_ = i < j ? i : j; int j_ = i < j ? j : i; uint128_t m = (uint128_t) x->l[i_] *

Dear all, I am using the function ?unfold? from the ?RcmdrPlugin.survival? to convert my time-varying covariates dataset from wide to long. I managed to have it working for my data. However, the problem I have is that the observations after an event, won?t be dropped from the dataset. For example, see the dataframe below: the event occurs at 1.2 (event.time=1), but the 1.3 to 1.6 will remain in

Hello All, I am trying to use the unfold function in RcmdrPlugin.survival library, which converts the survival data with time varying covariates to the counting process notation. The problem is somehow, the event indicator created is not correct. Below is the data, I am trying to convert: CASE TRT FAILTIME FAILCENS SEX AGE IGG0 IGG28 IGG42 IGG84 IGG364 26003 A 11.2033

Hi all, I have a question regarding a transformation that is carried out in InstCombine, which has been introduced by r48715. It unfolds expressions of the form `zext(or(icmp, (icmp)))` to `or(zext(icmp), zext(icmp)))` to expose pairs of `zext(icmp)`. In a subsequent iteration these `zext(icmp)` pairs could then (possibly) be optimized by another optimization (which has already been there before

I'm trying to put together an R routine to conduct unidimensional unfolding scaling analysis using maximum likelihood. My problem is that ML optimization will get stuck at latent scale points that are far from optimal. The point optimizes on one of the observed variables but not others and for ML to move away from this 'local optimum', it has to move in a direction in which the

Hi Sanjay, thank you a lot for your answer. I understand that in your examples it is desirable that `foo` and `goo` are canonicalized to the same IR, i.e., something like `@goo`. However, I still have a few open questions, but please correct me in case I'm thinking in the wrong direction. > Am 21.07.2016 um 18:51 schrieb Sanjay Patel <spatel at rotateright.com>: > > I've

Hi, SystemZ supports @llvm.ctlz.i64() natively with a single instruction (FLOGR), and lesser bitwidth versions of the intrinsic are promoted to i64. For some reason, this leads to unfolded additions of constants as shown below: This function: define i16 @fun(i16 %arg) {   %1 = tail call i16 @llvm.ctlz.i16(i16 %arg, i1 false)   ret i16 %1 } ,gives this optimized DAG as input to instruction selection: SelectionDAG has 15 nodes:   t0: ch = EntryToken                 t2: i32,ch...

...ot;2922" "2937" ... $ : chr [1:278] "3" "replication refresh "79" "79" "89" "79" "89" "79" "79" "79" ... I would like to transform the one above into a data frame where this structure in unfolded in the following way: 'data.frame': N obs. of 3 variables: $ time : int 1 1 1 1 1 1 1 1 1 1 1 ... $ partitioning_mode : chr "sharding" "sharding" "sharding" "sharding" "sharding" "sharding" "sharding" "sharding&...

Hi, I am attempting to modify LLVM to generate code for an architecture which is nearly identical to X86-64, but with a few minor differences. In particular, "call" must always have a register operand, and cannot have a memory operand. Any ideas on how I can express this rule? Thanks, - David -------------- next part -------------- An HTML attachment was scrubbed... URL:

On Tue, Jun 8, 2010 at 2:05 PM, David Meyer <pdox at google.com> wrote: > Hi, > I am attempting to modify LLVM to generate code for an architecture which is > nearly identical to X86-64, but with a few minor differences. > In particular, "call" must always have a register operand, and cannot have a > memory operand. Any ideas on how I can express this rule? Just get

Hi Sanjay, > Am 02.08.2016 um 21:39 schrieb Sanjay Patel <spatel at rotateright.com>: > > Hi Matthias - > > Sorry for the delayed reply. I think you're on the right path with D22864. No problem, thank you for your answer! > If I'm understanding it correctly, my foo() example and zext_or_icmp_icmp() will be equivalent after your patch is added to InstCombine.

I was always annoyed that you couldn't terminate an action with dbus so I have written this patch which fixes that. Hopefully this can be included. I wrote the patch trying to repeat as little code as possible so I just added a boolean parameter to the dbusHandleActivateMessage and changed the name to dbusHandleActivateDeactivateMessage. You could probably change the deactivate parameter

On Tue, Jun 8, 2010 at 4:20 PM, David Meyer <pdox at google.com> wrote: > Hi Eli, > I have tried this, but the resulting tool-chain was broken. > There are only two references to "CALL64m": the definition in > X86Instr64bit.td, and an entry in X86InstrInfo.cpp. > After commenting both out, compilation of a large application fails with: > llc: ScheduleDAG.cpp:462:

...gt; optim runs from within the user-given minimization function > they call. > > Optimization is unconstrained. > > > > I'm essentially using normal like curves that translate > observed values on a > > set of variables (one curve per variable) into latent > unfolded values. The > > observed values are on the Y-axis & the latent (hence > parameters to be > > estimated) are on the X-axis. The problem is that there > are two points into > > which an observed value can map on a curve--one on either > side of the curve > >...

After removing CALL64m, the resulting DAG has a cycle that cannot be scheduled. I've attached a PDF of the DAG before instruction selection (-view-isel-dags), and after instruction select (-view-sched-dags). Notice how the flag/chain relationships between MOV64rm and CALL64r make it impossible to schedule. Here's the code being compiled: define ccc void @ArgsFree() nounwind { entry:

Hi Eli, I have tried this, but the resulting tool-chain was broken. There are only two references to "CALL64m": the definition in X86Instr64bit.td, and an entry in X86InstrInfo.cpp. After commenting both out, compilation of a large application fails with: llc: ScheduleDAG.cpp:462: void llvm::ScheduleDAGTopologicalSort::InitDAGTopologicalSorting(): Assertion `Node2Index[SU->NodeNum]

Hi, I find that LSR is not helping enough on avoiding unfoldable offsets for SystemZ. When the loop has three stores with unfoldable offsets, LSR rewrites the IV in a good way. However, if adding another store with a foldable offset that fits already, LSR fails to rewrite the three stores. And if I happen to add a too big *positive* offset (the first three were negative) instead of a

i'm somehow embarrassed to even ask this, but is there any built-in method for doing this: my_list <- list() my_list[[1]] <- matrix(1:20, ncol = 5) my_list[[2]] <- matrix(20:1, ncol = 5) now, knowing that these matrices are identical in dimension, i'd like to unfold the list to a 2x4x5 (or some other permutation of the dim sizes) array. i know i can initialize the array, then