Gestione della memoria per interfacciare python e C++

[lucagalbu]

Ciao!
Devo riscrivere in C++ una funzione scritta in python. Vi posto il codice che ho scritto

static PyObject *crea_vicini(PyObject* self, PyObject *args)
{
  double N, L, rL;  //rL=raggio della sfera delle particelle vicine
  PyArrayObject *np_posizioni, *np_forza;
  PyListObject *l_vicini;

  if(!PyArg_ParseTuple(args, "dddO!O!:calcola_forza",
		       &N, &L, &rL,
		       &PyArray_Type, &np_posizioni,
		       &PyList_Type, &l_vicini))
    return NULL;
  
  NumPyArray posizioni(np_posizioni);
  PyList vicini(l_vicini);
  double distanza2[3];  //distanza al quadrato

  //eseguo l'equivalente C++ di
  //vicini=[ [] for i in xrange(N) ]
  l_vicini=(PyListObject*)PyList_New(0);
  for(int i=0; i<N; i++)  vicini.append(PyList_New(0));

  //se found=true vuol dire che ho trovato una particella immagine vicina a 
  //quella data e posso passare alla particella reale successiva
  bool found=false;

  //inizio ad analizzare i vicini di ogni particella
  //Ciclo su ogni particella
  for(int i=0; i<N; i++){
    //per ogni particella i considero la distanza da tutte le altre particelle
    //j, con j>i
    for(int j=i+1; j<N; j++){
      //all'inizio non ho ancora trovato una particella immagine vicina
      found=false;
      //ciclo su tutte le particelle immagine
      for(double shift_x=-L; shift_x<=L && (!found); shift_x+=L){
	distanza2[0]=posizioni(i,0)-posizioni(j,0)-shift_x;
	distanza2[0]*=distanza2[0];
	for(double shift_y=-L; shift_y<=L && (!found); shift_y+=L){
	  distanza2[1]=posizioni(i,1)-posizioni(j,1)-shift_y;
	  distanza2[1]*=distanza2[1];
	  for(double shift_z=-L; shift_z<=L && (!found); shift_z+=L){
	    distanza2[2]=posizioni(i,2)-posizioni(j,2)-shift_z;
	    distanza2[2]*=distanza2[2];

	    //se una particella immagine e' vicina...
	    if(distanza2[0]+distanza2[1]+distanza2[2] < rL*rL){
	      found=true;
	      PyList_Append(vicini(i), Py_BuildValue("i", j));
	      break;
	    }
	  }
	} 
      } //fine loop su particelle immagine
    } //fine loop su particella j>i 
  } //fine loop su particella i
  
  return Py_BuildValue("d", N);
}

Il problema è che ogni volta che chiamo questa funzione (viene chiamata circa 50mila volte all'interno del programma python) la quantità di memoria usata dal programma aumenta! Il problema sembra risiedere nella riga

PyList_Append(vicini(i), Py_BuildValue("i", j));

Non so che pesci pigliare... qualche idea?

[lucagalbu]

Cerco di dare una breve spiegazione di quello che la funzione fa: ho un sistema di N particelle. Per ogni particella devo creare creare una lista di particelle vicine, dove due particelle sono considerate vicine se la loro distanza è minore di un certo valore rL. Lasciate perdere il loop sulle particelle immagini, fate come se non ci fosse, non è quello che crea problemi. Per ogni particella i, la lista l_vicini[i] contiene la lista delle particelle vicine.