AutoThreading.cpp

Go to the documentation of this file.

// ==============================================================================================
// Microflow 3D, http://www.microflow.pwr.edu.pl/
// Created by Roman Szafran on 18.05.19.
// Last modified by Roman Szafran on 21.12.2019.
// Copyright (c) 2019 Wroclaw University of Science and Technology.
// Distributed under the Apache License, Version 2.0. You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0 or see accompanying file license.txt.
// Redistributions of source code must retain the above copyright and license notice.
// ==============================================================================================

#include "MFDatabase/AutoThreading.h"

void MF::Database::AutoThreading::GridThreading(const openvdb::Int64Grid::Ptr& VDBGrid_Ptr, std::shared_ptr<MF::Database::ThreadArray> & ThreadArray_Ptr) {

    struct nodeForAutoThreading {
        uint64_t NodeEncodedID = 1;
        uint32_t NodeNumber = 0;
    };

    nodeForAutoThreading newNode;
    auto NodeArray_Ptr = std::make_unique<std::vector<nodeForAutoThreading>>(1);
    uint64_t nodeEID; // nodeForAutoThreading NodeID + uid-thread number+1 + ThreadCount + ComponentNr + PhaseNr.
    unsigned char mark;

    //auto accessor = VDBGrid_Ptr->getAccessor();
    openvdb::Coord xyz;
    int32_t &i = xyz[0], &j = xyz[1], &h = xyz[2];

    // Counts nodes with the same nodeID
    for (auto iter = VDBGrid_Ptr->beginValueOn(); iter; ++iter) {
        mark = 0;
        nodeEID = iter.getValue();
        for (auto & it : *NodeArray_Ptr) {
            if (it.NodeEncodedID == nodeEID) {
                it.NodeNumber++;
                mark++;
            }
        }
        if (mark == 0) {
            newNode.NodeNumber = 1;
            newNode.NodeEncodedID = nodeEID;
            NodeArray_Ptr->push_back(newNode);
        }
        else if (mark > 1) {
            std::cout << "AutoThreading Error" << std::endl;
            exit(EXIT_FAILURE);
        }
    }

    // Add new thread to threads array
    for (auto & it : *NodeArray_Ptr) {
        ThreadArray_Ptr->NewThread(it.NodeEncodedID,it.NodeNumber);
    }

    // Add nodes coordinates to threads
    for (auto & thread1 : *ThreadArray_Ptr->m_ThreadsTable_Ptr){
        MF::GB::NodeID nodeTMP;
        nodeTMP.node_id.Node.nodeType = thread1->m_NodeType;
        nodeTMP.node_id.Node.uidThreadNr = thread1->m_uidThreadNr;
        nodeTMP.node_id.Node.ThreadCount = thread1->m_ThreadCount;
        nodeTMP.node_id.Node.ComponentNr = thread1->m_ComponentNr;
        nodeTMP.node_id.Node.PhaseNr = thread1->m_PhaseNr;
        auto iter2 = VDBGrid_Ptr->beginValueOn();
        for (size_t node = 0; node < thread1->m_NodeArray_Ptr->size(); node++) {
            for (auto iter = iter2; iter; ++iter) {
                if (iter.getValue() == nodeTMP.node_id.NodeID) {
                    xyz = iter.getCoord();
                    thread1->setNodeCoordX(node, i);
                    thread1->setNodeCoordY(node, j);
                    thread1->setNodeCoordZ(node, h);
                    iter2 = iter;
                    ++iter2;
                    break;
                }
            }
        }
    }

    NodeArray_Ptr.reset();

    // Create VDB grid of pointers
    using PointersTree = openvdb::tree::Tree4<uintptr_t, 5, 4, 3 >::Type;
    using PointersGrid = openvdb::Grid<PointersTree>;

    // Create an empty grid with background nodeForAutoThreading 0.
    auto PointersGrid_Ptr = PointersGrid::create(0);
    auto accessor2 = PointersGrid_Ptr->getAccessor();

    // Set pointers in VDB grid to thread nodes
    for (auto & thread2 : *ThreadArray_Ptr->m_ThreadsTable_Ptr){
        for (size_t node = 0; node < thread2->m_NodeArray_Ptr->size(); node++) {
            i = thread2->getNodeCoordX(node);
            j = thread2->getNodeCoordY(node);
            h = thread2->getNodeCoordZ(node);
            auto address1 = reinterpret_cast<uintptr_t>(thread2->getNodePointer(node));
            accessor2.setValue(xyz,address1);
        }
    }
    // Propagation pointers arrangement
    openvdb::CoordBBox its_bbox;
    VDBGrid_Ptr->treePtr()->evalActiveVoxelBoundingBox(its_bbox);
    auto Nx = its_bbox.dim().x();
    auto Ny = its_bbox.dim().y();
    auto Nz = its_bbox.dim().z();
    auto minX = its_bbox.min().x();
    auto maxX = its_bbox.max().x();
    auto minY = its_bbox.min().y();
    auto maxY = its_bbox.max().y();
    auto minZ = its_bbox.min().z();
    auto maxZ = its_bbox.max().z();

    // Set nodeForAutoThreading propagation pointers.
    for (auto & thread : *ThreadArray_Ptr->m_ThreadsTable_Ptr) {
        for (size_t node = 0; node < thread->m_NodeArray_Ptr->size(); node++) {
            thread->getNodeRef(node).pMyThread_Ptr = &thread; // Thread pointer initialization
            for (uint8_t ik = 0; ik < MFQ19_H ; ik++) {
                auto direction = MF::GU::LatticeParametersD3Q19::SwapDirections[ik][0];
                i = thread->getNodeCoordX(node) + MF::GU::LatticeParametersD3Q19::DirectionVectorComponent_Cx[direction];
                j = thread->getNodeCoordY(node) + MF::GU::LatticeParametersD3Q19::DirectionVectorComponent_Cy[direction];
                h = thread->getNodeCoordZ(node) + MF::GU::LatticeParametersD3Q19::DirectionVectorComponent_Cz[direction];
                auto value = accessor2.getValue(xyz);
                if (value != 0) {
                    thread->setNodePtrInPropTable(node,ik, reinterpret_cast<Node *>(accessor2.getValue(xyz))); //Fluid nodeForAutoThreading pointer.
                }
                else if (thread->m_NodeType != 4 && thread->m_NodeType != 5) { //For nodes outside te boundary
                    thread->setNodePtrInPropTable(node,ik, nullptr);
                }
                else { //Propagation for periodic boundary nodes
                    if (i < minX)
                        i = i + Nx;
                    else if (i > maxX)
                        i = i - Nx;
                    if (j < minY)
                        j = j + Ny;
                    else if (j > maxY)
                        j = j - Ny;
                    if (h < minZ)
                        h = h + Nz;
                    else if (h > maxZ)
                        h = h - Nz;
                    value = accessor2.getValue(xyz);
                    if (value != 0) {
                        thread->setNodePtrInPropTable(node,ik, reinterpret_cast<Node *>(accessor2.getValue(xyz))); // Periodic nodeForAutoThreading pointer.
                    }
                    else {
                        std::cout << "Lack of consistence of periodic boundary " << thread->m_NodeType << " nodeForAutoThreading: " << " (" << i << "," << j << "," << h << ") " << std::endl;
                        exit(EXIT_FAILURE);
                    }
                }
            }
        }
    }
    // Set second half nodeForAutoThreading propagation pointers.
    for (auto & thread : *ThreadArray_Ptr->m_ThreadsTable_Ptr) {
        for (size_t node = 0; node < thread->m_NodeArray_Ptr->size(); node++) {
            for (uint8_t ik = 0; ik < MFQ19_H ; ik++) {
                auto direction = MF::GU::LatticeParametersD3Q19::SwapDirections[ik][1];
                i = thread->getNodeCoordX(node) + MF::GU::LatticeParametersD3Q19::DirectionVectorComponent_Cx[direction];
                j = thread->getNodeCoordY(node) + MF::GU::LatticeParametersD3Q19::DirectionVectorComponent_Cy[direction];
                h = thread->getNodeCoordZ(node) + MF::GU::LatticeParametersD3Q19::DirectionVectorComponent_Cz[direction];
                auto value = accessor2.getValue(xyz);
                if (value != 0) {
                    thread->setNodePtrInSecondPropTable(node,ik, reinterpret_cast<Node *>(accessor2.getValue(xyz))); //Fluid nodeForAutoThreading pointer.
                }
                else if (thread->m_NodeType != 4 && thread->m_NodeType != 5) { //For nodes outside te boundary
                    thread->setNodePtrInSecondPropTable(node, ik,nullptr);
                }
                else { //Propagation for periodic boundary nodes
                    if (i < minX)
                        i = i + Nx;
                    else if (i > maxX)
                        i = i - Nx;
                    if (j < minY)
                        j = j + Ny;
                    else if (j > maxY)
                        j = j - Ny;
                    if (h < minZ)
                        h = h + Nz;
                    else if (h > maxZ)
                        h = h - Nz;
                    value = accessor2.getValue(xyz);
                    if (value != 0) {
                        thread->setNodePtrInSecondPropTable(node,ik, reinterpret_cast<Node *>(accessor2.getValue(xyz))); // Periodic nodeForAutoThreading pointer.
                    }
                    else {
                        std::cout << "Lack of consistence of periodic boundary " << thread->m_NodeType << " nodeForAutoThreading: " << " (" << i << "," << j << "," << h << ") " << std::endl;
                        exit(EXIT_FAILURE);
                    }
                }
            }
        }
    }
}

void MF::Database::AutoThreading::ThreadPartitioning(const openvdb::Int64Grid::Ptr &VDBGrid_Ptr, const std::shared_ptr<MF::Database::ConfigData>& ConfigData_Ptr) {

    uint32_t ThreadMaxSize {std::numeric_limits<uint32_t>::max()};
    if (ConfigData_Ptr->getCaseIntParam("ThreadParams.MFThreadMaxSize") < std::numeric_limits<uint32_t>::max()
            && ConfigData_Ptr->getCaseIntParam("ThreadParams.MFThreadMaxSize") != 0) {
        ThreadMaxSize = ConfigData_Ptr->getCaseIntParam("ThreadParams.MFThreadMaxSize");
    }

    struct nodeForAutoThreading {
        uint64_t NodeEncodedID = 1;
        uint64_t NodeNumber = 0;
    };

    nodeForAutoThreading newNode;
    auto NodeArray_Ptr = std::make_unique<std::vector<nodeForAutoThreading>>(1);
    uint64_t nodeEID; // nodeForAutoThreading NodeID + uid-thread number+1 + ThreadCount + ComponentNr + PhaseNr.
    MF::GB::NodeID nodeTMP;
    unsigned char mark;

    //auto accessor = VDBGrid_Ptr->getAccessor();
    openvdb::Coord xyz;
    int32_t &i = xyz[0], &j = xyz[1], &h = xyz[2];
    for (auto iter = VDBGrid_Ptr->beginValueOn(); iter; ++iter) {
        mark = 0;
        nodeEID = iter.getValue();
        for (auto &it : *NodeArray_Ptr) {
            if (it.NodeEncodedID == nodeEID) {
                it.NodeNumber++;
                mark++;
                if (it.NodeNumber >= ThreadMaxSize && (uint32_t)(it.NodeNumber / ThreadMaxSize) < std::numeric_limits<uint16_t>::max()) {
                    nodeTMP.node_id.NodeID = nodeEID;
                    nodeTMP.node_id.Node.ThreadCount = (uint32_t)(it.NodeNumber / ThreadMaxSize);
                    iter.setValue(nodeTMP.node_id.NodeID);
                } else if ((uint32_t)(it.NodeNumber / ThreadMaxSize) >= std::numeric_limits<uint16_t>::max()){ // Only 65535 MFThreads of the same type are allowed.
                    std::cout << "AutoThreading Error. Too many parts of MFThread: " << nodeEID << std::endl;
                    exit(EXIT_FAILURE);
                }
            }
        }
        if (mark == 0) {
            newNode.NodeNumber = 1;
            newNode.NodeEncodedID = nodeEID;
            NodeArray_Ptr->push_back(newNode);

        } else if (mark > 1) {
            std::cout << "AutoThreading Error" << std::endl;
            exit(EXIT_FAILURE);
        }
    }
    NodeArray_Ptr.reset();
}