Why isn’t the same Array shared between TaskGraphs in TornadoVM 1.1.1? How can I do double buffering with no copying of data?

[zealbell]

Why is the output here [0, 0, 0, 0, 0, 0, 0, 0] instead of [0, 2, 4, 6, 8, 10, 12, 14]?
Both graphs reference the same LongArray object on the host.

public static void opA(LongArray output) {
    for (@Parallel int i = 0; i < output.getSize(); i++) output.set(i, output.get(i) + i);
}

public static void opB(LongArray output) {
    for (@Parallel int i = 0; i < output.getSize(); i++) output.set(i, output.get(i) * 2);
}

public static void main(String[] args) {
    LongArray output = new LongArray(8);

    TaskGraph A = new TaskGraph("A").task("A0", Test::opA, output)
            .transferToHost(DataTransferMode.UNDER_DEMAND, output);
    TaskGraph B = new TaskGraph("B").task("B0", Test::opB, output)
            .transferToHost(DataTransferMode.UNDER_DEMAND, output);

    new TornadoExecutionPlan(A.snapshot()).execute();
    new TornadoExecutionPlan(B.snapshot()).execute().transferToHost(output);

    System.out.println("ACCUMULATION: " + Arrays.toString(output.toHeapArray()));
}

Why does TornadoVM not share the same device buffer between them, so that the idea of manipulating the same object is preserved?

I deliberately avoided transferring the output to the device for each graph to prevent values from being overwritten. However, it seems that the initially zeroed output is still being transferred or initialized twice on the device.

---

Context: I’m trying to implement double buffering on TornadoVM without copying input arrays, so I create two TaskGraph (one per input buffer) because I cannot reassign a different input array to a built TaskGraph. In practice my input buffer would be >= 1GB, so avoiding copies is critical.

public static void op(LongArray input, LongArray output) {
    for (@Parallel int i = 0; i < output.getSize(); i++) {
        output.set(i, input.get(i) + output.get(i));
    }
}

public static void main(String[] args) throws Exception {
    final int N = 8;
    final int NUM_BATCHES = 10; // example
    LongArray[] input = new LongArray[] { new LongArray(N), new LongArray(N) };
    LongArray output = new LongArray(N);

    TaskGraph A = new TaskGraph("A")
            .transferToHost(DataTransferMode.EVERY_EXECUTION, input[0])
            .task("A0", Test::op, input[0], output)
            .transferToHost(DataTransferMode.UNDER_DEMAND, output);

    TaskGraph B = new TaskGraph("B")
            .transferToHost(DataTransferMode.EVERY_EXECUTION, input[1])
            .task("B0", Test::op, input[1], output)
            .transferToHost(DataTransferMode.UNDER_DEMAND, output);

    TornadoExecutionPlan pa = new TornadoExecutionPlan(A.snapshot());
    TornadoExecutionPlan pb = new TornadoExecutionPlan(B.snapshot());

    for (int batch = 0; batch < NUM_BATCHES; batch++) {
        int current = batch % 2;             // which input buffer we fill this iteration
    
        fillInput(input[current], batch);//load data into the current input

        if (batch == NUM_BATCHES - 1) {
            // last batch: execute and transfer final output back to host
            if (current == 0) pa.execute().transferToHost(output);
            else pb.execute().transferToHost(output);
        } else {
            // non-final batch: fire execution only so that output accumulates across executions
            if (current == 0) pa.execute();
            else pb.execute();
        }

        // Next loop iteration will fill the other buffer while the previous execution runs. in practise execution would be scheduled to run on another thread so no execution blocks this loop
    }

    System.out.println("ACCUMULATION: " + Arrays.toString(output.toHeapArray()));
}

How can I do double buffering with no copying of data?

N.B. I am aware I could make input a ×2 capacity array in which I toggle which section is the current buffer so a single TaskGraph i.e. keep one device allocation and either pass an offset parameter to the kernel (or use two logical “views” / slices of the same LongArray) so the kernel reads input[offset + i]. I’m looking for a better approach because I don’t want the device to take up so much memory and I want transfers to host to be faster (smaller arrays); every cost counts since I will be doing multiple executions.