AuroraMiddleware/OpenSubdiv
1
0
Fork 0
mirror of https://github.com/PixarAnimationStudios/OpenSubdiv synced 2024-11-14 16:01:08 +00:00
Code Issues Releases Wiki Activity
63c189b5e6
OpenSubdiv/opensubdiv/osd/clEvaluator.cpp

532 lines
22 KiB
C++
Raw Normal View History

Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
//
// Copyright 2015 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#include "../osd/clEvaluator.h"
#include <sstream>
#include <string>
#include <vector>
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
#include <cstdio>
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
#include "../osd/opencl.h"
#include "../far/error.h"
renaming (2/2) PatchTables and StencilTables to PatchTable and StencilTable replace all occurrences reffering PatchTables, StencilTables, and their factories.
2015-05-22 18:50:01 +00:00
#include "../far/stencilTable.h"
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
namespace Osd {
static const char *clSource =
#include "clKernel.gen.h"
;
Osd Varying and FaceVarying Patch Evaluation Implemented EvalPatchesVarying and EvalPatchesFaceVarying methods for Osd::*Evaluator classes, i.e. cpu, omp, tbb, GLXFB, GLSLCompute, OpenCL, and CUDA. Also, the GPU Kernel implementations have been updated to use the common patchBasis implementation instead of re-implementing methods to compute patch basis weights locally.
2016-09-29 16:56:15 +00:00
static const char *patchBasisSource =
#include "patchBasisCommon.gen.h"
;
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
// ----------------------------------------------------------------------------
template <class T> cl_mem
createCLBuffer(std::vector<T> const & src, cl_context clContext) {
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
if (src.empty()) {
return NULL;
}
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
cl_int errNum = 0;
cl_mem devicePtr = clCreateBuffer(clContext,
CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,
src.size()*sizeof(T),
(void*)(&src.at(0)),
&errNum);
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR, "clCreateBuffer: %d", errNum);
}
return devicePtr;
}
// ----------------------------------------------------------------------------
renaming (2/2) PatchTables and StencilTables to PatchTable and StencilTable replace all occurrences reffering PatchTables, StencilTables, and their factories.
2015-05-22 18:50:01 +00:00
CLStencilTable::CLStencilTable(Far::StencilTable const *stencilTable,
cl_context clContext) {
_numStencils = stencilTable->GetNumStencils();
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
if (_numStencils > 0) {
renaming (2/2) PatchTables and StencilTables to PatchTable and StencilTable replace all occurrences reffering PatchTables, StencilTables, and their factories.
2015-05-22 18:50:01 +00:00
_sizes = createCLBuffer(stencilTable->GetSizes(), clContext);
_offsets = createCLBuffer(stencilTable->GetOffsets(), clContext);
_indices = createCLBuffer(stencilTable->GetControlIndices(),
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
clContext);
renaming (2/2) PatchTables and StencilTables to PatchTable and StencilTable replace all occurrences reffering PatchTables, StencilTables, and their factories.
2015-05-22 18:50:01 +00:00
_weights = createCLBuffer(stencilTable->GetWeights(), clContext);
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
_duWeights = _dvWeights = NULL;
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
_duuWeights = _duvWeights = _dvvWeights = NULL;
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
} else {
_sizes = _offsets = _indices = _weights = NULL;
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
_duWeights = _dvWeights = NULL;
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
_duuWeights = _duvWeights = _dvvWeights = NULL;
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
}
}
CLStencilTable::CLStencilTable(Far::LimitStencilTable const *limitStencilTable,
cl_context clContext) {
_numStencils = limitStencilTable->GetNumStencils();
if (_numStencils > 0) {
_sizes = createCLBuffer(limitStencilTable->GetSizes(), clContext);
_offsets = createCLBuffer(limitStencilTable->GetOffsets(), clContext);
_indices = createCLBuffer(limitStencilTable->GetControlIndices(),
clContext);
_weights = createCLBuffer(limitStencilTable->GetWeights(), clContext);
_duWeights = createCLBuffer(
limitStencilTable->GetDuWeights(), clContext);
_dvWeights = createCLBuffer(
limitStencilTable->GetDvWeights(), clContext);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
_duuWeights = createCLBuffer(
limitStencilTable->GetDuuWeights(), clContext);
_duvWeights = createCLBuffer(
limitStencilTable->GetDuvWeights(), clContext);
_dvvWeights = createCLBuffer(
limitStencilTable->GetDvvWeights(), clContext);
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
} else {
_sizes = _offsets = _indices = _weights = NULL;
_duWeights = _dvWeights = NULL;
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
_duuWeights = _duvWeights = _dvvWeights = NULL;
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
}
}
renaming (2/2) PatchTables and StencilTables to PatchTable and StencilTable replace all occurrences reffering PatchTables, StencilTables, and their factories.
2015-05-22 18:50:01 +00:00
CLStencilTable::~CLStencilTable() {
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
if (_sizes) clReleaseMemObject(_sizes);
if (_offsets) clReleaseMemObject(_offsets);
if (_indices) clReleaseMemObject(_indices);
if (_weights) clReleaseMemObject(_weights);
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
if (_duWeights) clReleaseMemObject(_duWeights);
if (_dvWeights) clReleaseMemObject(_dvWeights);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
if (_duuWeights) clReleaseMemObject(_duuWeights);
if (_duvWeights) clReleaseMemObject(_duvWeights);
if (_dvvWeights) clReleaseMemObject(_dvvWeights);
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
}
// ---------------------------------------------------------------------------
CLEvaluator::CLEvaluator(cl_context context, cl_command_queue queue)
: _clContext(context), _clCommandQueue(queue),
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
_program(NULL), _stencilKernel(NULL), _stencilDerivKernel(NULL),
_patchKernel(NULL) {
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
}
CLEvaluator::~CLEvaluator() {
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
if (_stencilKernel) clReleaseKernel(_stencilKernel);
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
if (_stencilDerivKernel) clReleaseKernel(_stencilDerivKernel);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
if (_patchKernel) clReleaseKernel(_patchKernel);
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
if (_program) clReleaseProgram(_program);
}
bool
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
CLEvaluator::Compile(BufferDescriptor const &srcDesc,
BufferDescriptor const &dstDesc,
BufferDescriptor const & /*duDesc*/,
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
BufferDescriptor const & /*dvDesc*/,
BufferDescriptor const & /*duuDesc*/,
BufferDescriptor const & /*duvDesc*/,
BufferDescriptor const & /*dvvDesc*/) {
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
if (srcDesc.length > dstDesc.length) {
Far::Error(Far::FAR_RUNTIME_ERROR,
"srcDesc length must be less than or equal to "
"dstDesc length.\n");
return false;
}
cl_int errNum;
std::ostringstream defines;
defines << "#define LENGTH " << srcDesc.length << "\n"
<< "#define SRC_STRIDE " << srcDesc.stride << "\n"
Osd Varying and FaceVarying Patch Evaluation Implemented EvalPatchesVarying and EvalPatchesFaceVarying methods for Osd::*Evaluator classes, i.e. cpu, omp, tbb, GLXFB, GLSLCompute, OpenCL, and CUDA. Also, the GPU Kernel implementations have been updated to use the common patchBasis implementation instead of re-implementing methods to compute patch basis weights locally.
2016-09-29 16:56:15 +00:00
<< "#define DST_STRIDE " << dstDesc.stride << "\n"
<< "#define OSD_PATCH_BASIS_OPENCL\n";
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
std::string defineStr = defines.str();
Osd Varying and FaceVarying Patch Evaluation Implemented EvalPatchesVarying and EvalPatchesFaceVarying methods for Osd::*Evaluator classes, i.e. cpu, omp, tbb, GLXFB, GLSLCompute, OpenCL, and CUDA. Also, the GPU Kernel implementations have been updated to use the common patchBasis implementation instead of re-implementing methods to compute patch basis weights locally.
2016-09-29 16:56:15 +00:00
const char *sources[] = { defineStr.c_str(), patchBasisSource, clSource };
_program = clCreateProgramWithSource(_clContext, 3, sources, 0, &errNum);
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR,
"clCreateProgramWithSource (%d)", errNum);
}
errNum = clBuildProgram(_program, 0, NULL, NULL, NULL, NULL);
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR, "clBuildProgram (%d) \n", errNum);
cl_int numDevices = 0;
clGetContextInfo(
_clContext, CL_CONTEXT_NUM_DEVICES,
sizeof(cl_uint), &numDevices, NULL);
cl_device_id *devices = new cl_device_id[numDevices];
clGetContextInfo(_clContext, CL_CONTEXT_DEVICES,
sizeof(cl_device_id)*numDevices, devices, NULL);
for (int i = 0; i < numDevices; ++i) {
char cBuildLog[10240];
clGetProgramBuildInfo(
_program, devices[i],
CL_PROGRAM_BUILD_LOG, sizeof(cBuildLog), cBuildLog, NULL);
Far::Error(Far::FAR_RUNTIME_ERROR, cBuildLog);
}
delete[] devices;
return false;
}
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
_stencilKernel = clCreateKernel(_program, "computeStencils", &errNum);
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR, "buildKernel (%d)\n", errNum);
return false;
}
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
_stencilDerivKernel = clCreateKernel(_program,
"computeStencilsDerivatives", &errNum);
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR, "buildKernel (%d)\n", errNum);
return false;
}
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
_patchKernel = clCreateKernel(_program, "computePatches", &errNum);
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR, "buildKernel (%d)\n", errNum);
return false;
}
return true;
}
bool
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
CLEvaluator::EvalStencils(cl_mem src, BufferDescriptor const &srcDesc,
cl_mem dst, BufferDescriptor const &dstDesc,
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
cl_mem sizes,
cl_mem offsets,
cl_mem indices,
cl_mem weights,
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
int start, int end,
unsigned int numStartEvents,
const cl_event* startEvents,
cl_event* endEvent) const {
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
if (end <= start) return true;
size_t globalWorkSize = (size_t)(end - start);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
clSetKernelArg(_stencilKernel, 0, sizeof(cl_mem), &src);
clSetKernelArg(_stencilKernel, 1, sizeof(int), &srcDesc.offset);
clSetKernelArg(_stencilKernel, 2, sizeof(cl_mem), &dst);
clSetKernelArg(_stencilKernel, 3, sizeof(int), &dstDesc.offset);
clSetKernelArg(_stencilKernel, 4, sizeof(cl_mem), &sizes);
clSetKernelArg(_stencilKernel, 5, sizeof(cl_mem), &offsets);
clSetKernelArg(_stencilKernel, 6, sizeof(cl_mem), &indices);
clSetKernelArg(_stencilKernel, 7, sizeof(cl_mem), &weights);
clSetKernelArg(_stencilKernel, 8, sizeof(int), &start);
clSetKernelArg(_stencilKernel, 9, sizeof(int), &end);
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
cl_int errNum = clEnqueueNDRangeKernel(
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
_clCommandQueue, _stencilKernel, 1, NULL,
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
&globalWorkSize, NULL, numStartEvents, startEvents, endEvent);
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR,
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
"ApplyStencilKernel (%d) ", errNum);
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
return false;
}
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
if (endEvent == NULL)
{
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
clFinish(_clCommandQueue);
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
}
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
return true;
}
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
bool
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
CLEvaluator::EvalStencils(cl_mem src, BufferDescriptor const &srcDesc,
cl_mem dst, BufferDescriptor const &dstDesc,
cl_mem du, BufferDescriptor const &duDesc,
cl_mem dv, BufferDescriptor const &dvDesc,
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
cl_mem sizes,
cl_mem offsets,
cl_mem indices,
cl_mem weights,
cl_mem duWeights,
cl_mem dvWeights,
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
int start, int end,
unsigned int numStartEvents,
const cl_event* startEvents,
cl_event* endEvent) const {
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
if (end <= start) return true;
size_t globalWorkSize = (size_t)(end - start);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
BufferDescriptor empty;
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
clSetKernelArg(_stencilDerivKernel, 0, sizeof(cl_mem), &src);
clSetKernelArg(_stencilDerivKernel, 1, sizeof(int), &srcDesc.offset);
clSetKernelArg(_stencilDerivKernel, 2, sizeof(cl_mem), &dst);
clSetKernelArg(_stencilDerivKernel, 3, sizeof(int), &dstDesc.offset);
clSetKernelArg(_stencilDerivKernel, 4, sizeof(cl_mem), &du);
clSetKernelArg(_stencilDerivKernel, 5, sizeof(int), &duDesc.offset);
clSetKernelArg(_stencilDerivKernel, 6, sizeof(int), &duDesc.stride);
clSetKernelArg(_stencilDerivKernel, 7, sizeof(cl_mem), &dv);
clSetKernelArg(_stencilDerivKernel, 8, sizeof(int), &dvDesc.offset);
clSetKernelArg(_stencilDerivKernel, 9, sizeof(int), &dvDesc.stride);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
clSetKernelArg(_stencilDerivKernel, 10, sizeof(cl_mem), NULL);
clSetKernelArg(_stencilDerivKernel, 11, sizeof(int), &empty.offset);
clSetKernelArg(_stencilDerivKernel, 12, sizeof(int), &empty.stride);
clSetKernelArg(_stencilDerivKernel, 13, sizeof(cl_mem), NULL);
clSetKernelArg(_stencilDerivKernel, 14, sizeof(int), &empty.offset);
clSetKernelArg(_stencilDerivKernel, 15, sizeof(int), &empty.stride);
clSetKernelArg(_stencilDerivKernel, 16, sizeof(cl_mem), NULL);
clSetKernelArg(_stencilDerivKernel, 17, sizeof(int), &empty.offset);
clSetKernelArg(_stencilDerivKernel, 18, sizeof(int), &empty.stride);
clSetKernelArg(_stencilDerivKernel, 19, sizeof(cl_mem), &sizes);
clSetKernelArg(_stencilDerivKernel, 20, sizeof(cl_mem), &offsets);
clSetKernelArg(_stencilDerivKernel, 21, sizeof(cl_mem), &indices);
clSetKernelArg(_stencilDerivKernel, 22, sizeof(cl_mem), &weights);
clSetKernelArg(_stencilDerivKernel, 23, sizeof(cl_mem), &duWeights);
clSetKernelArg(_stencilDerivKernel, 24, sizeof(cl_mem), &dvWeights);
clSetKernelArg(_stencilDerivKernel, 25, sizeof(cl_mem), NULL);
clSetKernelArg(_stencilDerivKernel, 26, sizeof(cl_mem), NULL);
clSetKernelArg(_stencilDerivKernel, 27, sizeof(cl_mem), NULL);
clSetKernelArg(_stencilDerivKernel, 28, sizeof(int), &start);
clSetKernelArg(_stencilDerivKernel, 29, sizeof(int), &end);
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
cl_int errNum = clEnqueueNDRangeKernel(
_clCommandQueue, _stencilDerivKernel, 1, NULL,
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
&globalWorkSize, NULL, numStartEvents, startEvents, endEvent);
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR,
"ApplyStencilKernel (%d) ", errNum);
return false;
}
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
if (endEvent == NULL) {
clFinish(_clCommandQueue);
}
return true;
}
bool
CLEvaluator::EvalStencils(cl_mem src, BufferDescriptor const &srcDesc,
cl_mem dst, BufferDescriptor const &dstDesc,
cl_mem du, BufferDescriptor const &duDesc,
cl_mem dv, BufferDescriptor const &dvDesc,
cl_mem duu, BufferDescriptor const &duuDesc,
cl_mem duv, BufferDescriptor const &duvDesc,
cl_mem dvv, BufferDescriptor const &dvvDesc,
cl_mem sizes,
cl_mem offsets,
cl_mem indices,
cl_mem weights,
cl_mem duWeights,
cl_mem dvWeights,
cl_mem duuWeights,
cl_mem duvWeights,
cl_mem dvvWeights,
int start, int end,
unsigned int numStartEvents,
const cl_event* startEvents,
cl_event* endEvent) const {
if (end <= start) return true;
size_t globalWorkSize = (size_t)(end - start);
clSetKernelArg(_stencilDerivKernel, 0, sizeof(cl_mem), &src);
clSetKernelArg(_stencilDerivKernel, 1, sizeof(int), &srcDesc.offset);
clSetKernelArg(_stencilDerivKernel, 2, sizeof(cl_mem), &dst);
clSetKernelArg(_stencilDerivKernel, 3, sizeof(int), &dstDesc.offset);
clSetKernelArg(_stencilDerivKernel, 4, sizeof(cl_mem), &du);
clSetKernelArg(_stencilDerivKernel, 5, sizeof(int), &duDesc.offset);
clSetKernelArg(_stencilDerivKernel, 6, sizeof(int), &duDesc.stride);
clSetKernelArg(_stencilDerivKernel, 7, sizeof(cl_mem), &dv);
clSetKernelArg(_stencilDerivKernel, 8, sizeof(int), &dvDesc.offset);
clSetKernelArg(_stencilDerivKernel, 9, sizeof(int), &dvDesc.stride);
clSetKernelArg(_stencilDerivKernel, 10, sizeof(cl_mem), &duu);
clSetKernelArg(_stencilDerivKernel, 11, sizeof(int), &duuDesc.offset);
clSetKernelArg(_stencilDerivKernel, 12, sizeof(int), &duuDesc.stride);
clSetKernelArg(_stencilDerivKernel, 13, sizeof(cl_mem), &duv);
clSetKernelArg(_stencilDerivKernel, 14, sizeof(int), &duvDesc.offset);
clSetKernelArg(_stencilDerivKernel, 15, sizeof(int), &duvDesc.stride);
clSetKernelArg(_stencilDerivKernel, 16, sizeof(cl_mem), &dvv);
clSetKernelArg(_stencilDerivKernel, 17, sizeof(int), &dvvDesc.offset);
clSetKernelArg(_stencilDerivKernel, 18, sizeof(int), &dvvDesc.stride);
clSetKernelArg(_stencilDerivKernel, 19, sizeof(cl_mem), &sizes);
clSetKernelArg(_stencilDerivKernel, 20, sizeof(cl_mem), &offsets);
clSetKernelArg(_stencilDerivKernel, 21, sizeof(cl_mem), &indices);
clSetKernelArg(_stencilDerivKernel, 22, sizeof(cl_mem), &weights);
clSetKernelArg(_stencilDerivKernel, 23, sizeof(cl_mem), &duWeights);
clSetKernelArg(_stencilDerivKernel, 24, sizeof(cl_mem), &dvWeights);
clSetKernelArg(_stencilDerivKernel, 25, sizeof(cl_mem), &duuWeights);
clSetKernelArg(_stencilDerivKernel, 26, sizeof(cl_mem), &duvWeights);
clSetKernelArg(_stencilDerivKernel, 27, sizeof(cl_mem), &dvvWeights);
clSetKernelArg(_stencilDerivKernel, 28, sizeof(int), &start);
clSetKernelArg(_stencilDerivKernel, 29, sizeof(int), &end);
cl_int errNum = clEnqueueNDRangeKernel(
_clCommandQueue, _stencilDerivKernel, 1, NULL,
&globalWorkSize, NULL, numStartEvents, startEvents, endEvent);
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR,
"ApplyStencilKernel (%d) ", errNum);
return false;
}
if (endEvent == NULL) {
clFinish(_clCommandQueue);
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
}
Add GPU stencil/patch derivative kernels implements cuda, CL, GLXFB and GLCompute kernels of derivative evaluation for both limit stencils and patches.
2015-05-28 00:23:36 +00:00
return true;
}
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
bool
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
CLEvaluator::EvalPatches(cl_mem src, BufferDescriptor const &srcDesc,
cl_mem dst, BufferDescriptor const &dstDesc,
cl_mem du, BufferDescriptor const &duDesc,
cl_mem dv, BufferDescriptor const &dvDesc,
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
int numPatchCoords,
cl_mem patchCoordsBuffer,
cl_mem patchArrayBuffer,
cl_mem patchIndexBuffer,
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
cl_mem patchParamBuffer,
unsigned int numStartEvents,
const cl_event* startEvents,
cl_event* endEvent) const {
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
size_t globalWorkSize = (size_t)(numPatchCoords);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
BufferDescriptor empty;
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
clSetKernelArg(_patchKernel, 0, sizeof(cl_mem), &src);
clSetKernelArg(_patchKernel, 1, sizeof(int), &srcDesc.offset);
clSetKernelArg(_patchKernel, 2, sizeof(cl_mem), &dst);
clSetKernelArg(_patchKernel, 3, sizeof(int), &dstDesc.offset);
Fix OpenCL and CUDA EvalPatches kernels.
2015-05-26 18:13:30 +00:00
clSetKernelArg(_patchKernel, 4, sizeof(cl_mem), &du);
clSetKernelArg(_patchKernel, 5, sizeof(int), &duDesc.offset);
clSetKernelArg(_patchKernel, 6, sizeof(int), &duDesc.stride);
clSetKernelArg(_patchKernel, 7, sizeof(cl_mem), &dv);
clSetKernelArg(_patchKernel, 8, sizeof(int), &dvDesc.offset);
clSetKernelArg(_patchKernel, 9, sizeof(int), &dvDesc.stride);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
clSetKernelArg(_patchKernel, 10, sizeof(cl_mem), NULL);
clSetKernelArg(_patchKernel, 11, sizeof(int), &empty.offset);
clSetKernelArg(_patchKernel, 12, sizeof(int), &empty.stride);
clSetKernelArg(_patchKernel, 13, sizeof(cl_mem), NULL);
clSetKernelArg(_patchKernel, 14, sizeof(int), &empty.offset);
clSetKernelArg(_patchKernel, 15, sizeof(int), &empty.stride);
clSetKernelArg(_patchKernel, 16, sizeof(cl_mem), NULL);
clSetKernelArg(_patchKernel, 17, sizeof(int), &empty.offset);
clSetKernelArg(_patchKernel, 18, sizeof(int), &empty.stride);
clSetKernelArg(_patchKernel, 19, sizeof(cl_mem), &patchCoordsBuffer);
clSetKernelArg(_patchKernel, 20, sizeof(cl_mem), &patchArrayBuffer);
clSetKernelArg(_patchKernel, 21, sizeof(cl_mem), &patchIndexBuffer);
clSetKernelArg(_patchKernel, 22, sizeof(cl_mem), &patchParamBuffer);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
cl_int errNum = clEnqueueNDRangeKernel(
_clCommandQueue, _patchKernel, 1, NULL,
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
&globalWorkSize, NULL, numStartEvents, startEvents, endEvent);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR,
"ApplyPatchKernel (%d) ", errNum);
return false;
}
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
if (endEvent == NULL) {
clFinish(_clCommandQueue);
Add events control to clVertexBuffer and clEvaluator
2015-11-23 09:54:03 +00:00
}
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
return true;
}
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
bool
CLEvaluator::EvalPatches(cl_mem src, BufferDescriptor const &srcDesc,
cl_mem dst, BufferDescriptor const &dstDesc,
cl_mem du, BufferDescriptor const &duDesc,
cl_mem dv, BufferDescriptor const &dvDesc,
cl_mem duu, BufferDescriptor const &duuDesc,
cl_mem duv, BufferDescriptor const &duvDesc,
cl_mem dvv, BufferDescriptor const &dvvDesc,
int numPatchCoords,
cl_mem patchCoordsBuffer,
cl_mem patchArrayBuffer,
cl_mem patchIndexBuffer,
cl_mem patchParamBuffer,
unsigned int numStartEvents,
const cl_event* startEvents,
cl_event* endEvent) const {
size_t globalWorkSize = (size_t)(numPatchCoords);
clSetKernelArg(_patchKernel, 0, sizeof(cl_mem), &src);
clSetKernelArg(_patchKernel, 1, sizeof(int), &srcDesc.offset);
clSetKernelArg(_patchKernel, 2, sizeof(cl_mem), &dst);
clSetKernelArg(_patchKernel, 3, sizeof(int), &dstDesc.offset);
clSetKernelArg(_patchKernel, 4, sizeof(cl_mem), &du);
clSetKernelArg(_patchKernel, 5, sizeof(int), &duDesc.offset);
clSetKernelArg(_patchKernel, 6, sizeof(int), &duDesc.stride);
clSetKernelArg(_patchKernel, 7, sizeof(cl_mem), &dv);
clSetKernelArg(_patchKernel, 8, sizeof(int), &dvDesc.offset);
clSetKernelArg(_patchKernel, 9, sizeof(int), &dvDesc.stride);
clSetKernelArg(_patchKernel, 10, sizeof(cl_mem), &duu);
clSetKernelArg(_patchKernel, 11, sizeof(int), &duuDesc.offset);
clSetKernelArg(_patchKernel, 12, sizeof(int), &duuDesc.stride);
clSetKernelArg(_patchKernel, 13, sizeof(cl_mem), &duv);
clSetKernelArg(_patchKernel, 14, sizeof(int), &duvDesc.offset);
clSetKernelArg(_patchKernel, 15, sizeof(int), &duvDesc.stride);
clSetKernelArg(_patchKernel, 16, sizeof(cl_mem), &dvv);
clSetKernelArg(_patchKernel, 17, sizeof(int), &dvvDesc.offset);
clSetKernelArg(_patchKernel, 18, sizeof(int), &dvvDesc.stride);
clSetKernelArg(_patchKernel, 19, sizeof(cl_mem), &patchCoordsBuffer);
clSetKernelArg(_patchKernel, 20, sizeof(cl_mem), &patchArrayBuffer);
clSetKernelArg(_patchKernel, 21, sizeof(cl_mem), &patchIndexBuffer);
clSetKernelArg(_patchKernel, 22, sizeof(cl_mem), &patchParamBuffer);
cl_int errNum = clEnqueueNDRangeKernel(
_clCommandQueue, _patchKernel, 1, NULL,
&globalWorkSize, NULL, numStartEvents, startEvents, endEvent);
if (errNum != CL_SUCCESS) {
Far::Error(Far::FAR_RUNTIME_ERROR,
"ApplyPatchKernel (%d) ", errNum);
return false;
}
if (endEvent == NULL) {
clFinish(_clCommandQueue);
}
return true;
}
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
/* static */
void
CLEvaluator::Synchronize(cl_command_queue clCommandQueue) {
clFinish(clCommandQueue);
}
} // end namespace Osd
} // end namespace OPENSUBDIV_VERSION
} // end namespace OpenSubdiv
Reference in New Issue Copy Permalink