Is it possifble to change the receptorLigand::generateReceptors to a multi-thread version

Below is some response from gpt4 maybe helpful, but I can not sure it works.

To make the selected code multi-threaded, we can use the pthread library to create multiple threads that can execute the for loop in parallel.

First, we need to declare a function that will be executed by each thread. This function should take a void argument and return a void value. In our case, we can define a function generateReceptorsThread that takes a pointer to a set object as its argument and returns NULL. This function will execute the for loop in the original code, but only for the positions in the given set.

void* generateReceptorsThread(void* arg){
    set<int>* positions = (set<int>*) arg;
    std::set<int>::iterator it;
    for (it = positions->begin(); it != positions->end(); ++it)
    {
        // original code here
    }
    return NULL;
}

Next, we need to create multiple threads and pass the appropriate arguments to each thread. We can use the pthread_create function to create a new thread and pass the set of positions as its argument. We can store the thread IDs in an array so that we can join them later.

const int NUM_THREADS = 4; // number of threads to create
pthread_t threads[NUM_THREADS];
set<int> startingPositions = neighborPositions(ligand, forbiddenVolume);
int nR = 0;
int threadIndex = 0;
std::set<int>::iterator it;
size_t counter = 0;
int cptPos = 0;
cout << "   -> Start computing structures from each bordering position. Nr of bordering/Starting positions: " << startingPositions.size() << endl;
for (it = startingPositions.begin(); it != startingPositions.end(); ++it)
{
    if(DBGgenRecept) cout << " ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----" << endl;
    cptPos++;
    int pos = *it;
    if(!contains(forbiddenVolume, pos)){

        // either the protein starts by an interaction, so starts here. Only one direction
        for(int d1 = 0; d1 < Nb_Moves_Absolute; ++d1){
            int neighbor1 = position(pos, (moveDirection) d1);
            if((!contains(ligand.occupiedPositions, neighbor1)) && (!contains(forbiddenVolume, neighbor1))){

                vector<struct3D*> toAdd = generateProteins(sizeReceptor, pos, (moveDirection) d1, minimalNInteract - 1, false, ligand, forbiddenVolume);
                size_t NTA = toAdd.size();
                for(size_t i = 0; i < NTA; ++i){
                    possibleReceptors.push_back(toAdd[i]);
                    nR++;
                }
                if(DBGgenRecept) cout << nR << "\tPosition " << printVector(lattice::positionFromID(pos));
                if(DBGgenRecept) cout << " Dir " << intToMoveChar(d1) << ", " << NTA << " sequences starting from an interaction there" << endl;
            }
        }

        // for each couple of possible directions ...
        vector<std::pair<moveDirection, moveDirection> > possibleDirections;
        for(int d1 = 0; d1 < Nb_Moves_Absolute; ++d1){
            for(int d2 = d1+1; d2 < Nb_Moves_Absolute; ++d2){// the two moves should be different.

                // conditions on the two directions :
                // direction 1 should not touch again the protein,
                //           and the following structure should not touch the protein either
                // direction 2 can touch again.
                // if dir1 and dir2 don't touch, explore in both orders.
                int neighbor1 = position(pos, (moveDirection) d1);
                int neighbor2 = position(pos, (moveDirection) d2);

                // if both directions are free
                if((!contains(ligand.occupiedPositions, neighbor1)) &&
                        (!contains(ligand.occupiedPositions, neighbor2)) && (!contains(forbiddenVolume, neighbor1)) && (!contains(forbiddenVolume, neighbor2))){
                    // condition : first direction should not touch. If both do so, both order possible.
                    if(!touch(ligand, neighbor1)){
                        possibleDirections.push_back(std::pair<moveDirection, moveDirection>((moveDirection) d1, (moveDirection) d2));
                    }
                    if(!touch(ligand, neighbor2)){
                        possibleDirections.push_back(std::pair<moveDirection, moveDirection>((moveDirection) d2, (moveDirection) d1));
                    }
                }
            }
        }
        size_t nDir = possibleDirections.size();
        for(size_t i = 0; i < nDir; ++i){
            // create a new thread and pass the set of positions as its argument
            pthread_create(&threads[threadIndex], NULL, generateReceptorsThread, (void*) &possibleDirections[i]);
            threadIndex++;
            if(threadIndex == NUM_THREADS){
                // join all threads before creating new ones
                for(int j = 0; j < NUM_THREADS; j++){
                    pthread_join(threads[j], NULL);
                }
                threadIndex = 0;
            }
        }
    }
}
// join any remaining threads
for(int j = 0; j < threadIndex; j++){
    pthread_join(threads[j], NULL);
}

In the modified code, we create a fixed number of threads (NUM_THREADS) and join them after processing a fixed number of positions. This helps to limit the number of threads created and reduces the overhead of thread creation and destruction.

Note that we need to include the pthread.h header file and link against the pthread library to use the pthread functions.

csi-greifflab / Absolut

Is it possifble to change the receptorLigand::generateReceptors to a multi-thread version #20