Tutorial 28 - Node with simple OGN computeVectorized

This tutorial demonstrates how to compose nodes that implements a very simple computeVectorized function. It shows how to access the data, using the different available methods.

OgnTutorialVectorizedPassthrough.ogn

The ogn file shows the implementation of a node named “omni.graph.tutorials.TutorialVectorizedPassThrough”, which takes input of a floating point value, and just copy it to its output.

{
    "TutorialVectorizedPassThrough": {
        "version": 1,
        "description": "Simple passthrough node that copy its input to its output in a vectorized way",
        "categories": "tutorials",
        "uiName": "Tutorial Node: Vectorized Passthrough",
        "inputs":{
            "value":{
                "type": "float",
                "description": "input value"
            }
        },
        "outputs": {
            "value": {
                "type": "float",
                "description": "output value"
            }
        },
        "tests" : [
            { "inputs:value": 1, "outputs:value": 1 },
            { "inputs:value": 2, "outputs:value": 2 },
            { "inputs:value": 3, "outputs:value": 3 },
            { "inputs:value": 4, "outputs:value": 4 }
        ]
    }
}

OgnTutorialVectorizedPassthrough.cpp

The cpp file contains the implementation of the node. It takes a floating point input and just copy it to its output, demonstrating how to handle a vectorized compute. It shows what would be the implementation for a regular compute function, and the different way it could implement a computeVectorized function. - method #1: by switching the entire database to the next instance, while performing the computation in a loop - method #2: by directly indexing attributes for the right instance in a loop - method #3: by retrieving the raw data, and working directly with it

// SPDX-FileCopyrightText: Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
//
// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
// property and proprietary rights in and to this material, related
// documentation and any modifications thereto. Any use, reproduction,
// disclosure or distribution of this material and related documentation
// without an express license agreement from NVIDIA CORPORATION or
// its affiliates is strictly prohibited.
#include <OgnTutorialVectorizedPassthroughDatabase.h>

// The method used by the computation to perform the passthrough
// 0 = simple copy, no vectorization
#define TUTO_PASSTHROUGH_METHOD_SIMPLE 0

// 1 = vectorized copy by moving the entire database to the next instance
#define TUTO_PASSTHROUGH_METHOD_DB 1

// 2 = vectorized copy by indexing the instance directly per attribute
#define TUTO_PASSTHROUGH_METHOD_ATTR 2

// 3 = vectorized copy using raw data
#define TUTO_PASSTHROUGH_METHOD_RAW 3

// By default, use the most efficient method
#define TUTO_PASSTHROUGH_METHOD TUTO_PASSTHROUGH_METHOD_RAW

// This node perform a copy of its input to its output
class OgnTutorialVectorizedPassthrough
{
public:
#if TUTO_PASSTHROUGH_METHOD == TUTO_PASSTHROUGH_METHOD_SIMPLE
    // begin-regular
    static bool compute(OgnTutorialVectorizedPassthroughDatabase& db)
    {
        db.outputs.value() = db.inputs.value();
        return true;
    }
    // end-regular
#elif TUTO_PASSTHROUGH_METHOD == TUTO_PASSTHROUGH_METHOD_DB
    // begin-db
    static size_t computeVectorized(OgnTutorialVectorizedPassthroughDatabase& db, size_t count)
    {
        for (size_t idx = 0; idx < count; ++idx)
        {
            db.outputs.value() = db.inputs.value();
            db.moveToNextInstance();
        }
        return count;
    }
    // end-db
#elif TUTO_PASSTHROUGH_METHOD == TUTO_PASSTHROUGH_METHOD_ATTR
    // begin-attr
    static size_t computeVectorized(OgnTutorialVectorizedPassthroughDatabase& db, size_t count)
    {
        for (size_t idx = 0; idx < count; ++idx)
            db.outputs.value(idx) = db.inputs.value(idx);
        return count;
    }
    // end-attr
#elif TUTO_PASSTHROUGH_METHOD == TUTO_PASSTHROUGH_METHOD_RAW
    // begin-raw
    static size_t computeVectorized(OgnTutorialVectorizedPassthroughDatabase& db, size_t count)
    {
        auto spanIn = db.inputs.value.vectorized(count);
        auto spanOut = db.outputs.value.vectorized(count);

        memcpy(spanOut.data(), spanIn.data(), std::min(spanIn.size_bytes(), spanOut.size_bytes()));

        return count;
    }
    // end-raw
#endif
};

REGISTER_OGN_NODE()