Actually moving data to device, not sure its correct

Atraxus · ichinii · commit 5c5e056631e4 · 2025-07-16T09:25:44.000+02:00
diff --git a/Intern/rayx-core/src/RaySoA.cpp b/Intern/rayx-core/src/RaySoA.cpp
@@ -33,7 +33,9 @@ RaySoA bundleHistoryToRaySoA(const BundleHistory& bundle) {
 BundleHistory raySoAToBundleHistory(const RaySoA& rays) {
     RAYX_PROFILE_FUNCTION_STDOUT();
 
-    auto bundle = BundleHistory(rays.num_paths);
+    if (rays.num_events == 0) return BundleHistory();
+    int maxPathId = *std::max_element(rays.path_id.begin(), rays.path_id.end());
+    auto bundle = BundleHistory(maxPathId + 1);
 
     for (int i = 0; i < rays.num_events; ++i) {
         const auto path_id = rays.path_id[i];
diff --git a/Intern/rayx-core/src/Shader/DynamicElements.cpp b/Intern/rayx-core/src/Shader/DynamicElements.cpp
@@ -60,7 +60,7 @@ void dynamicElements(const int gid, const InvState& inv, OutputEvents& outputEve
         }
 
         // write ray in local element coordinates to global memory
-        if (!inv.recordMask || inv.recordMask[col.elementIndex]) {
+        if (numRecorded < inv.maxEvents && (!inv.recordMask || inv.recordMask[col.elementIndex])) {
             outputEvents.events[gid * inv.maxEvents + numRecorded] = ray;
             ++numRecorded;
         }
diff --git a/Intern/rayx-core/src/Shader/EventType.h b/Intern/rayx-core/src/Shader/EventType.h
@@ -59,7 +59,7 @@ inline std::string findEventTypeString(const EventType eventType) {
         case EventType::Emitted:
             return "Emitted";
         default:
-            _debug_throw("unable to convert EventType (%d) to string!", static_cast<int>(eventType));
+            //_debug_throw("unable to convert EventType (%d) to string!", static_cast<int>(eventType));
             return "<unknown-event-type>";
     }
 }
diff --git a/Intern/rayx-core/src/Tracer/DeviceTracer.h b/Intern/rayx-core/src/Tracer/DeviceTracer.h
@@ -9,6 +9,11 @@
 
 namespace RAYX {
 
+// Small helper to make passing the full record mask easier. 
+inline std::vector<bool> fullRecordMask(size_t numElements) {
+    return std::vector<bool>(numElements, true);
+}
+
 /**
  * @brief DeviceTracer is an interface to a tracer implementation
  * we use this interface to remove the actual implementation from the rayx api
@@ -17,8 +22,13 @@ class RAYX_API DeviceTracer {
   public:
     virtual ~DeviceTracer() = default;
 
-    virtual RaySoA trace(const Group&, Sequential sequential, const int maxBatchSize, const int maxEvents, std::shared_ptr<bool[]> recordMask,
-                         const RayAttrFlag attr) = 0;
+    virtual RaySoA trace(
+        const Group& beamline, 
+        Sequential sequential, 
+        const int maxBatchSize, 
+        const int maxEvents, 
+        const std::vector<bool>& recordMask, 
+        const RayAttrFlag attr) = 0;
 };
 
 }  // namespace RAYX
diff --git a/Intern/rayx-core/src/Tracer/MegaKernelTracer.h b/Intern/rayx-core/src/Tracer/MegaKernelTracer.h
@@ -43,6 +43,8 @@ struct Resources {
     // resources per beamline. constant per beamline
     /// beamline elements
     Buf<OpticalElement> d_elements;
+    /// mask for which elements to record events
+    Buf<bool> d_recordMask;
     /// all rays generated from all light sources
     std::vector<Ray> h_rays;
 
@@ -75,7 +77,7 @@ struct Resources {
 
     /// update resources
     template <typename Queue>
-    Config update(Queue q, const Group& group, int maxEvents, int maxBatchSize) {
+    Config update(Queue q, const Group& group, int maxEvents, int maxBatchSize, const std::vector<bool>& recordMask) {
         RAYX_PROFILE_FUNCTION_STDOUT();
 
         const auto platformHost = alpaka::PlatformCpu{};
@@ -98,6 +100,16 @@ struct Resources {
         allocBuf(q, d_elements, numElements);
         alpaka::memcpy(q, *d_elements, alpaka::createView(devHost, elements, numElements));
 
+        // record mask
+        assert(recordMask.size() == static_cast<size_t>(numElements));
+        allocBuf(q, d_recordMask, numElements);
+        std::unique_ptr<bool[]> tmpHostMask(new bool[numElements]);
+        for(int i = 0; i < numElements; ++i) {
+            tmpHostMask[i] = recordMask[i];
+        }
+        auto hostView = alpaka::createView(devHost, tmpHostMask.get(), numElements);
+        alpaka::memcpy(q, *d_recordMask, hostView);
+
         // input rays
         h_rays = group.compileSources(1);  // TODO: generate rays on device
         const auto numRaysTotal = static_cast<int>(h_rays.size());
@@ -149,8 +161,13 @@ class MegaKernelTracer : public DeviceTracer {
     Resources<Acc> m_resources;
 
   public:
-    virtual RaySoA trace(const Group& beamline, const Sequential sequential, const int maxBatchSize, const int maxEvents,
-                         std::shared_ptr<bool[]> recordMask, const RayAttrFlag attr) override {
+    virtual RaySoA trace(
+        const Group& beamline, 
+        Sequential sequential, 
+        const int maxBatchSize, 
+        const int maxEvents, 
+        const std::vector<bool>& recordMask, 
+        const RayAttrFlag attr) override {
         RAYX_PROFILE_FUNCTION_STDOUT();
 
         const auto platformHost = alpaka::PlatformCpu{};
@@ -160,7 +177,7 @@ class MegaKernelTracer : public DeviceTracer {
         using Queue = alpaka::Queue<Acc, alpaka::Blocking>;
         auto q = Queue(devAcc);
 
-        const auto conf = m_resources.update(q, beamline, maxEvents, maxBatchSize);
+        const auto conf = m_resources.update(q, beamline, maxEvents, maxBatchSize, recordMask);
         const auto randomSeed = randomDouble();
 
         RAYX_VERB << "tracing beamline:";
@@ -199,9 +216,8 @@ class MegaKernelTracer : public DeviceTracer {
             alpaka::memcpy(q, *m_resources.d_rays, raysViewBatch);
 
             // trace current batch
-            traceBatch(devAcc, q, conf.numElements, conf.numRaysTotal, batchSize, batchStartRayIndex, maxEvents, recordMask, randomSeed, sequential);
+            traceBatch(devAcc, q, conf.numElements, conf.numRaysTotal, batchSize, batchStartRayIndex, maxEvents, randomSeed, sequential);
 
-            // prefix sum on compactEventCounts to get compactEventOffsets
             alpaka::memcpy(q, alpaka::createView(devHost, compactEventCounts, batchSize), *m_resources.d_compactEventCounts, batchSize);
             std::exclusive_scan(compactEventCounts.begin(), compactEventCounts.begin() + batchSize, compactEventOffsets.begin(), 0);
             alpaka::memcpy(q, *m_resources.d_compactEventOffsets, alpaka::createView(devHost, compactEventOffsets, batchSize), batchSize);
@@ -259,7 +275,7 @@ class MegaKernelTracer : public DeviceTracer {
   private:
     template <typename DevAcc, typename Queue>
     void traceBatch(DevAcc devAcc, Queue q, int numElements, int numRaysTotal, int batchSize, int batchStartRayIndex, int maxEvents,
-                    std::shared_ptr<bool[]> recordMask, double randomSeed, Sequential sequential) {
+                    double randomSeed, Sequential sequential) {
         RAYX_PROFILE_FUNCTION_STDOUT();
 
         // inputs
@@ -277,7 +293,7 @@ class MegaKernelTracer : public DeviceTracer {
             .numElements = numElements,
             .materialIndices = alpaka::getPtrNative(*m_resources.d_materialIndices),
             .materialTables = alpaka::getPtrNative(*m_resources.d_materialTable),
-            .recordMask = recordMask.get(),
+            .recordMask = alpaka::getPtrNative(*m_resources.d_recordMask),
             .rays = alpaka::getPtrNative(*m_resources.d_rays),
         };
 
diff --git a/Intern/rayx-core/src/Tracer/Tracer.cpp b/Intern/rayx-core/src/Tracer/Tracer.cpp
@@ -51,8 +51,7 @@ Tracer::Tracer(const DeviceConfig& deviceConfig) {
     }
 }
 
-RaySoA Tracer::trace(const Group& group, Sequential sequential, uint64_t maxBatchSize, uint32_t maxEvents, std::shared_ptr<bool[]> recordMask,
-                     RayAttrFlag attr) {
+RaySoA Tracer::trace(const Group& group, Sequential sequential, uint64_t maxBatchSize, uint32_t maxEvents, const std::vector<bool>& recordMask, const RayAttrFlag attr) {
     // in sequential tracing, maxEvents should be equal to the number of elements
     if (sequential == Sequential::Yes) maxEvents = group.numElements();
 
diff --git a/Intern/rayx-core/src/Tracer/Tracer.h b/Intern/rayx-core/src/Tracer/Tracer.h
@@ -29,8 +29,14 @@ class RAYX_API Tracer {
     // This will call the trace implementation of a subclass
     // See `BundleHistory` for information about the return value.
     // `max_batch_size` corresponds to the maximal number of rays that will be put into `traceRaw` in one batch.
-    RaySoA trace(const Group& group, Sequential sequential, uint64_t maxBatchSize, uint32_t maxEvents, std::shared_ptr<bool[]> recordMask = nullptr,
-                 RayAttrFlag attr = RayAttrFlag::All);
+
+    RaySoA trace(
+        const Group& group, 
+        const Sequential sequential, 
+        uint64_t maxBatchSize, 
+        uint32_t maxEvents, 
+        const std::vector<bool>& recordMask,
+        const RayAttrFlag attr = RayAttrFlag::All);
 
     static int defaultMaxEvents(const Group* group);
 
diff --git a/Intern/rayx-core/tests/input/CircleSource_default.h5 b/Intern/rayx-core/tests/input/CircleSource_default.h5
diff --git a/Intern/rayx-core/tests/input/ToroidGrating.h5 b/Intern/rayx-core/tests/input/ToroidGrating.h5
diff --git a/Intern/rayx-core/tests/input/loadDatFile.h5 b/Intern/rayx-core/tests/input/loadDatFile.h5
diff --git a/Intern/rayx-core/tests/setupTests.cpp b/Intern/rayx-core/tests/setupTests.cpp
@@ -77,7 +77,8 @@ void writeToOutputCSV(const RAYX::BundleHistory& hist, std::string filename) {
 
 RAYX::BundleHistory traceRML(std::string filename) {
     const auto beamline = loadBeamline(filename);
-    const auto rays = tracer->trace(beamline, Sequential::No, DEFAULT_BATCH_SIZE, beamline.numElements() + 2);
+    const auto numElements = beamline.numElements();
+    const auto rays = tracer->trace(beamline, Sequential::No, DEFAULT_BATCH_SIZE, numElements + 2, fullRecordMask(numElements));
     return raySoAToBundleHistory(rays);
 }
 
@@ -177,7 +178,9 @@ std::optional<RAYX::Ray> lastSequentialHit(RayHistory ray_hist, uint32_t beamlin
 // returns the rayx rays converted to be ray-UI compatible.
 std::vector<RAYX::Ray> rayUiCompat(std::string filename, Sequential seq) {
     const auto beamline = loadBeamline(filename);
-    const auto rays = tracer->trace(beamline, seq, DEFAULT_BATCH_SIZE, beamline.numElements() + 2);
+    const auto numElements = beamline.numElements();
+    const auto rays = tracer->trace(beamline, seq, DEFAULT_BATCH_SIZE, beamline.numElements() + 2, fullRecordMask(numElements));
+
     const auto hist = raySoAToBundleHistory(rays);
 
     std::vector<RAYX::Ray> out;
diff --git a/Intern/rayx-ui/src/Simulator.cpp b/Intern/rayx-ui/src/Simulator.cpp
@@ -17,7 +17,7 @@ void Simulator::runSimulation() {
         m_maxEvents = RAYX::Tracer::defaultMaxEvents(&m_Beamline);
     }
 
-    const auto rays = m_Tracer->trace(m_Beamline, m_seq, m_max_batch_size, m_maxEvents);
+    const auto rays = m_Tracer->trace(m_Beamline, m_seq, m_max_batch_size, m_maxEvents, RAYX::fullRecordMask(m_Beamline.numElements()));
     const auto bundleHist = RAYX::raySoAToBundleHistory(rays);
 
     bool notEnoughEvents = false;
diff --git a/Intern/rayx/src/TerminalApp.cpp b/Intern/rayx/src/TerminalApp.cpp
@@ -155,15 +155,27 @@ void TerminalApp::tracePath(const std::filesystem::path& path) {
         RAYX::Sequential seq = m_CommandParser->m_args.m_sequential ? RAYX::Sequential::Yes : RAYX::Sequential::No;
         const int maxEvents =
             (m_CommandParser->m_args.m_maxEvents < 1) ? RAYX::Tracer::defaultMaxEvents(m_Beamline.get()) : m_CommandParser->m_args.m_maxEvents;
-        auto recordIndices = m_CommandParser->m_args.m_recordIndices;
         size_t numElements = m_Beamline->numElements();
-        auto recordMask = std::make_shared<bool[]>(numElements);
-        std::fill_n(recordMask.get(), numElements, false);
-        for (auto idx : recordIndices) {
-            if (idx < 0) RAYX_EXIT << "Only positive indices are possible for CLI option: -R/--record-indices!";
-            if (idx > numElements - 1) RAYX_EXIT << "Index {" << idx << "} provided with -R/--record-indices does not exist in the provided file.";
-            recordMask[idx] = true;
+
+        // Record mask
+        auto recordIndices = m_CommandParser->m_args.m_recordIndices;
+        std::vector<bool> recordMask(numElements, true);
+        if (!recordIndices.empty()) {
+            recordMask = std::vector<bool>(numElements, false);
+            for (auto idx : recordIndices) {
+                if (idx < 0) RAYX_EXIT << "Only positive indices are possible for CLI option: -R/--record-indices!";
+                if (idx > numElements - 1) RAYX_EXIT << "Index {" << idx << "} provided with -R/--record-indices does not exist in the provided file.";
+                recordMask[idx] = true;
+            }
+        }
+
+        // Verbose log: print mask as a string of 0s and 1s
+        std::string maskStr;
+        maskStr.reserve(numElements);
+        for (auto b : recordMask) {
+            maskStr += b;
         }
+        RAYX_VERB << "recordMask [size=" << numElements << "]: " << maskStr;
 
         const auto attr =
             m_CommandParser->m_args.m_format.empty() ? RAYX::RayAttrFlag::All : RAYX::formatStringToRayAttrFlag(m_CommandParser->m_args.m_format);
diff --git a/errors.txt b/errors.txt
diff --git a/tmp.txt b/tmp.txt

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ void dynamicElements(const int gid, const InvState& inv, OutputEvents& outputEve`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`// write ray in local element coordinates to global memory`
`63`		`- if (!inv.recordMask \|\| inv.recordMask[col.elementIndex]) {`
	`63`	`+ if (numRecorded < inv.maxEvents && (!inv.recordMask \|\| inv.recordMask[col.elementIndex])) {`
`64`	`64`	`outputEvents.events[gid * inv.maxEvents + numRecorded] = ray;`
`65`	`65`	`++numRecorded;`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ inline std::string findEventTypeString(const EventType eventType) {`
`59`	`59`	`case EventType::Emitted:`
`60`	`60`	`return "Emitted";`
`61`	`61`	`default:`
`62`		`- _debug_throw("unable to convert EventType (%d) to string!", static_cast<int>(eventType));`
	`62`	`+ //_debug_throw("unable to convert EventType (%d) to string!", static_cast<int>(eventType));`
`63`	`63`	`return "<unknown-event-type>";`
`64`	`64`	`}`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,8 +51,7 @@ Tracer::Tracer(const DeviceConfig& deviceConfig) {`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`-RaySoA Tracer::trace(const Group& group, Sequential sequential, uint64_t maxBatchSize, uint32_t maxEvents, std::shared_ptr<bool[]> recordMask,`
`55`		`- RayAttrFlag attr) {`
	`54`	`+RaySoA Tracer::trace(const Group& group, Sequential sequential, uint64_t maxBatchSize, uint32_t maxEvents, const std::vector<bool>& recordMask, const RayAttrFlag attr) {`
`56`	`55`	`// in sequential tracing, maxEvents should be equal to the number of elements`
`57`	`56`	`if (sequential == Sequential::Yes) maxEvents = group.numElements();`
`58`	`57`