/*
DESCRIPTION
Constructor for the EnvImpl class.
PARAMETERS:
drvName driver name
charset charset id
ncharset ncharset id
RETURNS:
nothing
NOTES:
*/
EnvImpl::EnvImpl( const string &drvName,
unsigned int charset,
unsigned int ncharset )
try : envh_(NULL), poolMax_(kPoolMax), poolMin_(kPoolMin),
poolIncrement_(kPoolIncrement), poolTimeout_(kPoolTimeout),
externalAuth_(false), stmtCacheSize_(kStmtCacheSize), drvName_(drvName),
charset_ ( charset ), ncharset_ ( ncharset )
{
sword rc = OCIEnvNlsCreate (&envh_, OCI_THREADED | OCI_OBJECT, NULL, NULL,
NULL, NULL, 0, NULL, charset, ncharset);
if (rc)
{
if (envh_)
ociCallEnv(rc, envh_);
else
throw ExceptionImpl(DpiErrNoEnv);
}
DateTimeArrayImpl::initBaseDate ( envh_ ) ;
}
catch (...)
{
cleanup();
throw;
}
EnvImpl::EnvImpl()
try : envh_(NULL), poolMax_(kPoolMax), poolMin_(kPoolMin),
poolIncrement_(kPoolIncrement), poolTimeout_(kPoolTimeout),
externalAuth_(false), stmtCacheSize_(kStmtCacheSize)
{
sword rc = OCIEnvNlsCreate (&envh_, OCI_THREADED | OCI_OBJECT, NULL, NULL,
NULL, NULL, 0, NULL, DPI_AL32UTF8, DPI_AL32UTF8);
if (rc)
{
if (envh_)
ociCallEnv(rc, envh_);
else
throw ExceptionImpl(DpiErrNoEnv);
}
DateTimeArrayImpl::initBaseDate ( envh_ ) ;
}
catch (...)
{
cleanup();
throw;
}
void HlbvhStrategy::QueryOcclusion(std::uint32_t queueidx, Calc::Buffer const* rays, Calc::Buffer const* numrays, std::uint32_t maxrays, Calc::Buffer* hits, Calc::Event const* waitevent, Calc::Event** event) const
{
// Check if we can allocate enough stack memory
if (maxrays >= kMaxBatchSize)
{
throw ExceptionImpl("hlbvh accelerator max batch size exceeded");
}
auto& func = m_gpudata->occlude_indirect_func;
// Set args
int arg = 0;
int offset = 0;
func->SetArg(arg++, m_bvh->GetGpuData().nodes);
func->SetArg(arg++, m_bvh->GetGpuData().sorted_bounds);
func->SetArg(arg++, m_gpudata->vertices);
func->SetArg(arg++, m_gpudata->faces);
func->SetArg(arg++, m_gpudata->shapes);
func->SetArg(arg++, rays);
func->SetArg(arg++, sizeof(offset), &offset);
func->SetArg(arg++, numrays);
func->SetArg(arg++, hits);
func->SetArg(arg++, m_gpudata->stack);
size_t localsize = kWorkGroupSize;
size_t globalsize = ((maxrays + kWorkGroupSize - 1) / kWorkGroupSize) * kWorkGroupSize;
m_device->Execute(func, queueidx, globalsize, localsize, event);
}
/*
DESCRIPTION
To obtain Oracle Client Library (OCI) version
PARAMETERS
majorv
minorv
patchv
portv
portUpdv
RETURNS
-NONE-
NOTES:
The values will map as Oracle Version like 12.1.0.2.0 - five component
version of Oracle Client Library
*/
void Common::clientVersion ( int *majorv, int *minorv, int *patchv,
int *portv, int *portUpdv )
{
if ( !majorv || !minorv || !patchv || !portv || !portUpdv )
throw ExceptionImpl ( DpiErrNullValue );
OCIClientVersion ( majorv, minorv, patchv, portv, portUpdv );
}
/*
NAME
getDateTimeArray
DESCRIPTION
To obtain an DPI class which represents date/timestamp as descriptor
array
RETURNS:
DateTimeArray * -
NOTE:
DatetimeArray uses error object created in StmtImpl instead of creating
separate one, this is ok, as the date/timestamp will be part of SQL
statement execution only.
*/
DateTimeArray* EnvImpl::getDateTimeArray (OCIError *errh) const
{
DateTimeArray *dtmarr = new DateTimeArrayImpl ( envh_, errh, this ) ;
if( !dtmarr )
{
throw ExceptionImpl ( DpiErrMemAllocFail ) ;
}
return dtmarr;
}
static void ociCallCommon(sword rc, void *handle, ub4 errType)
{
if (!rc)
return;
OraText ociErrorMsg[OCI_ERROR_MAXMSG_SIZE];
sb4 ociErrorNo = 0;
memset(ociErrorMsg, 0, OCI_ERROR_MAXMSG_SIZE);
rc = OCIErrorGet(handle, 1, NULL, &ociErrorNo, ociErrorMsg,
OCI_ERROR_MAXMSG_SIZE-1, errType);
if (rc)
throw ExceptionImpl(DpiErrUnkOciError);
else
{
ociErrorMsg[strlen((char*)ociErrorMsg)-1]=0; //strip off newline
throw ExceptionImpl("ORA", ociErrorNo, (const char *)ociErrorMsg);
}
}
const char *StringPimpl::c_str() const throw(Exception &)
{
try
{
return m_pimpl->proxy.c_str();
}
catch(Exception &e)
{
throw ExceptionImpl(e.what());
}
}
bool StringPimpl::empty() const throw(Exception &)
{
try
{
return m_pimpl->proxy.empty();
}
catch(std::exception &e)
{
throw ExceptionImpl(e.what());
}
}
StringPimpl::StringPimpl(const StringPimpl& stringPimpl)
: m_pimpl(0)
{
try
{
init(stringPimpl.c_str());
}
catch(std::exception &e)
{
throw ExceptionImpl(e.what());
}
}
StringPimpl::StringPimpl(const char * const stringPimpl) throw(Exception &)
: m_pimpl(0)
{
try
{
init(stringPimpl);
}
catch(std::exception &e)
{
throw ExceptionImpl(e.what());
}
}
StringPimpl::StringPimpl() throw(Exception &)
: m_pimpl(0)
{
try
{
m_pimpl = new StringPrivate;
}
catch(std::exception &e)
{
throw ExceptionImpl(e.what());
}
}
void StringPimpl::init(const char * const stringPimpl)
{
if(stringPimpl == 0)
{
logging("Error trying to put 0 into a string");
throw ExceptionImpl("Error in StringPimpl::init, trying to put 0 into a string");
}
else
{
delete m_pimpl;
m_pimpl = new StringPrivate;
m_pimpl->proxy = stringPimpl;
}
}
Mesh::Mesh(float const* vertices, int vnum, int vstride,
int const* vidx, int vistride,
int const* nfaceverts,
int nfaces)
: puretriangle_(true)
{
// Handle vertices
// Allocate space in advance
vertices_.resize(vnum);
// Calculate vertex stride, assume dense packing if non passed
vstride = (vstride == 0) ? (3 * sizeof(float)) : vstride;
// Allocate space for faces
faces_.resize(nfaces);
// Load vertices
#pragma omp parallel for
for (int i = 0; i < vnum; ++i)
{
float const* current = (float const*)((char*)vertices + i*vstride);
float3 temp;
temp.x = current[0];
temp.y = current[1];
temp.z = current[2];
vertices_[i] = temp;
}
// If mesh consists of triangles only apply parallel loading
if (nfaceverts == nullptr)
{
puretriangle_ = true;
int istride = (vistride == 0) ? (3 * sizeof(int)) : vistride;
#pragma omp parallel for
for (int i = 0; i < nfaces; ++i)
{
faces_[i].i0 = *((int const*)((char const*)vidx + i * istride));
faces_[i].i1 = *((int const*)((char const*)vidx + i * istride + sizeof(int)));
faces_[i].i2 = *((int const*)((char const*)vidx + i * istride + 2 * sizeof(int)));
faces_[i].type_ = FaceType::TRIANGLE;
}
}
// Otherwise execute serially
else
{
char const* vidxptr = (char const*)vidx;
for (int i = 0; i < nfaces; ++i)
{
// Triangle case
if (nfaceverts[i] == 3)
{
faces_[i].i0 = *((int const*)(vidxptr));
faces_[i].i1 = *((int const*)(vidxptr + sizeof(int)));
faces_[i].i2 = *((int const*)(vidxptr + 2 * sizeof(int)));
faces_[i].type_ = FaceType::TRIANGLE;
// Goto next primitive
vidxptr += (vistride == 0) ? (3 * sizeof(int)) : vistride;
}
// Quad case
else if (nfaceverts[i] == 4)
{
faces_[i].i0 = *((int const*)(vidxptr));
faces_[i].i1 = *((int const*)(vidxptr + sizeof(int)));
faces_[i].i2 = *((int const*)(vidxptr + 2 * sizeof(int)));
faces_[i].i3 = *((int const*)(vidxptr + 3 * sizeof(int)));
faces_[i].type_ = FaceType::QUAD;
puretriangle_ = false;
// Goto next primitive
vidxptr += (vistride == 0) ? (4 * sizeof(int)) : vistride;
}
else
{
throw ExceptionImpl("Wrong number of vertices per face");
}
}
}
}
void IntersectorShortStack::Process(World const& world)
{
// If something has been changed we need to rebuild BVH
if (!m_bvh || world.has_changed() || world.GetStateChange() != ShapeImpl::kStateChangeNone)
{
if (m_bvh)
{
m_device->DeleteBuffer(m_gpudata->bvh);
m_device->DeleteBuffer(m_gpudata->vertices);
}
// Check if we can allocate enough stack memory
Calc::DeviceSpec spec;
m_device->GetSpec(spec);
if (spec.max_alloc_size <= kMaxBatchSize * kMaxStackSize * sizeof(int))
{
throw ExceptionImpl("fatbvh accelerator can't allocate enough stack memory, try using bvh instead");
}
int numshapes = (int)world.shapes_.size();
int numvertices = 0;
int numfaces = 0;
// This buffer tracks mesh start index for next stage as mesh face indices are relative to 0
std::vector<int> mesh_vertices_start_idx(numshapes);
std::vector<int> mesh_faces_start_idx(numshapes);
auto builder = world.options_.GetOption("bvh.builder");
auto splits = world.options_.GetOption("bvh.sah.use_splits");
auto maxdepth = world.options_.GetOption("bvh.sah.max_split_depth");
auto overlap = world.options_.GetOption("bvh.sah.min_overlap");
auto tcost = world.options_.GetOption("bvh.sah.traversal_cost");
auto node_budget = world.options_.GetOption("bvh.sah.extra_node_budget");
auto nbins = world.options_.GetOption("bvh.sah.num_bins");
bool use_sah = false;
bool use_splits = false;
int max_split_depth = maxdepth ? (int)maxdepth->AsFloat() : 10;
int num_bins = nbins ? (int)nbins->AsFloat() : 64;
float min_overlap = overlap ? overlap->AsFloat() : 0.05f;
float traversal_cost = tcost ? tcost->AsFloat() : 10.f;
float extra_node_budget = node_budget ? node_budget->AsFloat() : 0.5f;
if (builder && builder->AsString() == "sah")
{
use_sah = true;
}
if (splits && splits->AsFloat() > 0.f)
{
use_splits = true;
}
m_bvh.reset(use_splits ?
new SplitBvh(traversal_cost, num_bins, max_split_depth, min_overlap, extra_node_budget) :
new Bvh(traversal_cost, num_bins, use_sah)
);
// Partition the array into meshes and instances
std::vector<Shape const*> shapes(world.shapes_);
auto firstinst = std::partition(shapes.begin(), shapes.end(),
[&](Shape const* shape)
{
return !static_cast<ShapeImpl const*>(shape)->is_instance();
});
// Count the number of meshes
int nummeshes = (int)std::distance(shapes.begin(), firstinst);
// Count the number of instances
int numinstances = (int)std::distance(firstinst, shapes.end());
for (int i = 0; i < nummeshes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
mesh_faces_start_idx[i] = numfaces;
mesh_vertices_start_idx[i] = numvertices;
numfaces += mesh->num_faces();
numvertices += mesh->num_vertices();
}
// We can't avoild allocating it here, since bounds aren't stored anywhere
std::vector<bbox> bounds(numfaces);
// We handle meshes first collecting their world space bounds
#pragma omp parallel for
for (int i = 0; i < nummeshes; ++i)
{
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
for (int j = 0; j < mesh->num_faces(); ++j)
{
// Here we directly get world space bounds
mesh->GetFaceBounds(j, false, bounds[mesh_faces_start_idx[i] + j]);
}
}
// Then we handle instances. Need to flatten them into actual geometry.
#pragma omp parallel for
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
// Instance is using its own transform for base shape geometry
// so we need to get object space bounds and transform them manually
matrix m, minv;
instance->GetTransform(m, minv);
for (int j = 0; j < mesh->num_faces(); ++j)
{
bbox tmp;
mesh->GetFaceBounds(j, true, tmp);
bounds[mesh_faces_start_idx[i] + j] = transform_bbox(tmp, m);
}
}
m_bvh->Build(&bounds[0], numfaces);
#ifdef RR_PROFILE
m_bvh->PrintStatistics(std::cout);
#endif
// Check if the tree height is reasonable
if (m_bvh->GetHeight() >= kMaxStackSize)
{
m_bvh.reset(nullptr);
throw ExceptionImpl("fatbvh accelerator can cause stack overflow for this scene, try using bvh instead");
}
FatNodeBvhTranslator translator;
translator.Process(*m_bvh);
// Update GPU data
// Create vertex buffer
{
// Vertices
m_gpudata->vertices = m_device->CreateBuffer(numvertices * sizeof(float3), Calc::BufferType::kRead);
// Get the pointer to mapped data
float3* vertexdata = nullptr;
Calc::Event* e = nullptr;
m_device->MapBuffer(m_gpudata->vertices, 0, 0, numvertices * sizeof(float3), Calc::MapType::kMapWrite, (void**)&vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
// Here we need to put data in world space rather than object space
// So we need to get the transform from the mesh and multiply each vertex
matrix m, minv;
#pragma omp parallel for
for (int i = 0; i < nummeshes; ++i)
{
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(shapes[i]);
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
mesh->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
#pragma omp parallel for
for (int i = nummeshes; i < nummeshes + numinstances; ++i)
{
Instance const* instance = static_cast<Instance const*>(shapes[i]);
// Get the mesh
Mesh const* mesh = static_cast<Mesh const*>(instance->GetBaseShape());
// Get vertex buffer of the current mesh
float3 const* myvertexdata = mesh->GetVertexData();
// Get mesh transform
instance->GetTransform(m, minv);
//#pragma omp parallel for
// Iterate thru vertices multiply and append them to GPU buffer
for (int j = 0; j < mesh->num_vertices(); ++j)
{
vertexdata[mesh_vertices_start_idx[i] + j] = transform_point(myvertexdata[j], m);
}
}
m_device->UnmapBuffer(m_gpudata->vertices, 0, vertexdata, &e);
e->Wait();
m_device->DeleteEvent(e);
}
// Create face buffer
{
// This number is different from the number of faces for some BVHs
auto numindices = m_bvh->GetNumIndices();
std::vector<FatNodeBvhTranslator::Face> facedata(numindices);
// Here the point is to add mesh starting index to actual index contained within the mesh,
// getting absolute index in the buffer.
// Besides that we need to permute the faces accorningly to BVH reordering, whihc
// is contained within bvh.primids_
int const* reordering = m_bvh->GetIndices();
for (int i = 0; i < numindices; ++i)
{
int indextolook4 = reordering[i];
// We need to find a shape corresponding to current face
auto iter = std::upper_bound(mesh_faces_start_idx.cbegin(), mesh_faces_start_idx.cend(), indextolook4);
// Find the index of the shape
int shapeidx = static_cast<int>(std::distance(mesh_faces_start_idx.cbegin(), iter) - 1);
// Get the mesh directly or out of instance
Mesh const* mesh = nullptr;
if (shapeidx < nummeshes)
{
mesh = static_cast<Mesh const*>(shapes[shapeidx]);
}
else
{
mesh = static_cast<Mesh const*>(static_cast<Instance const*>(shapes[shapeidx])->GetBaseShape());
}
// Get vertex buffer of the current mesh
Mesh::Face const* myfacedata = mesh->GetFaceData();
// Find face idx
int faceidx = indextolook4 - mesh_faces_start_idx[shapeidx];
// Find mesh start idx
int mystartidx = mesh_vertices_start_idx[shapeidx];
// Copy face data to GPU buffer
facedata[i].idx[0] = myfacedata[faceidx].idx[0] + mystartidx;
facedata[i].idx[1] = myfacedata[faceidx].idx[1] + mystartidx;
facedata[i].idx[2] = myfacedata[faceidx].idx[2] + mystartidx;
facedata[i].shapeidx = shapes[shapeidx]->GetId();
facedata[i].shape_mask = shapes[shapeidx]->GetMask();
facedata[i].id = faceidx;
}
translator.InjectIndices(&facedata[0]);
}
// Copy translated nodes first
m_gpudata->bvh = m_device->CreateBuffer(translator.nodes_.size() * sizeof(FatNodeBvhTranslator::Node), Calc::BufferType::kRead, &translator.nodes_[0]);
// Stack
m_gpudata->stack = m_device->CreateBuffer(kMaxBatchSize*kMaxStackSize, Calc::BufferType::kWrite);
// Make sure everything is commited
m_device->Finish(0);
}
}
void TestCases::conductTesting()
{
if(m_testFileAdded && m_aimlFileAdded && m_aimlGraphCreated)
{
try
{
if(m_testValidation && (!m_testSchema.empty()))
{
string SchemaLoc = "http://alicebot.org/2001/AIML-1.0.1 " + m_testSchema;
m_testParser->setDoSchema(true);
//m_testParser->setDoValidation(true); // optional.
m_testParser->setDoNamespaces(true); // optional
m_testParser->setExternalSchemaLocation(SchemaLoc.c_str());
}
else
{
m_testParser->setDoSchema(false);
//m_testParser->setDoValidation(false); // optional.
m_testParser->setDoNamespaces(false); // optional
}
typedef map<string, bool>::iterator I;
for(I i = m_filesGraphed.begin(); i != m_filesGraphed.end(); ++i)
{
if(i->second == false)
{
cout << i->first << " has not been added to graph yet";
m_testParser->parse((i->first).c_str());
i->second = true;
}
else
{ //Do nothing
cout << i->first << " has been added to the graph already";
cout << "Just returning, without doing anything";
}
}
}
catch (const XMLException& toCatch)
{
Transcode message(toCatch.getMessage());
string msg("XMLException: " + message.getString());
cout << msg << endl;
throw ExceptionImpl(msg.c_str());
}
catch (const SAXParseException& toCatch)
{
Transcode message(toCatch.getMessage());
string msg("SAXParseException: " + message.getString());
cout << msg << endl;
throw ExceptionImpl(msg.c_str());
}
}
else
{
throw ExceptionImpl("You need to add a test file, at least one aiml File,"
" and create the aiml graph");
}
}