Eu estou escrevendo um software em c # que precisa chamar muitas vezes e por muitos threads uma função em uma DLL não gerenciada c ++.

Eu tenho um arquivo C ++ assim:

// "variables" which consist in some simple variables (int, double) 
//  and in some complex variables (structs containing arrays of structs)


extern "C"
{
     __declspec(dllexport) int function1()
    {
        // some work depending on random and on the "variables"
    }
}

e uma classe C # assim

public class class1
{
    //  "variables" <--- the "same" as the C++ file's ones 
    //  Dll import <--- ok

    public void method1()
    {
        int [] result;

        for(int i=0; i<many_times; i++)
        {
            result = new int[number_of_parallel_tasks];                

            Parallel.For(0, number_of_parallel_tasks, delegate(int j)
            { 
                 // I would like to do  result[j] = function1()  
            });

            //  choose best result
            //  then update "variables" 
        }
    }

}

Eu escrevi "Eu gostaria de fazer ..." porque a função c ++ precisa em cada rodada para ter as "variáveis" atualizadas também.

Minha pergunta é:

É possível compartilhar memória entre C ++ e C # para evitar a referência de passagem toda vez? É apenas uma perda de tempo?

Eu li sobre arquivos mapeados na memória. Eles poderiam me ajudar? No entanto, você conhece soluções mais adequadas?
Muito obrigado.