+ Rispondi al Thread
Visualizzazione dei risultati da 1 a 2 su 2

Discussione: Gestione della memoria per interfacciare python e C++

  1. #1
    lucagalbu non è in linea Scolaretto
    Luogo
    Italy
    Post
    244

    Gestione della memoria per interfacciare python e C++

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

    codice:
    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
    codice:
    PyList_Append(vicini(i), Py_BuildValue("i", j));
    Non so che pesci pigliare... qualche idea?
    Ultima modifica di lucagalbu; 29-12-2012 17:14 
    Colui che pone una domanda è uno sciocco per cinque minuti; colui che non pone una domanda rimane uno sciocco per sempre

  2. #2
    lucagalbu non è in linea Scolaretto
    Luogo
    Italy
    Post
    244
    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.
    Colui che pone una domanda è uno sciocco per cinque minuti; colui che non pone una domanda rimane uno sciocco per sempre

+ Rispondi al Thread

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi