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

Gestione della memoria per interfacciare python e C++

  1. #1
    lucagalbu non  in linea Scolaretto
    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?
    Ultima modifica di lucagalbu; 29-12-2012 17:14 
    ℹ️ Leggi di pi su lucagalbu ...

  2. #2
    lucagalbu non  in linea Scolaretto
    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.
    ℹ️ Leggi di pi su lucagalbu ...

+ Rispondi al messaggio

Potrebbero interessarti anche ...

  1. Risposte: 1
    Ultimo Post: 26-04-2012, 16:08
  2. Gestione della memoria
    Da getfar nel forum Visual Basic .Net
    Risposte: 5
    Ultimo Post: 23-07-2010, 16:47
  3. Gestione Memoria Heap / Stack
    Da xardas nel forum C/C++
    Risposte: 4
    Ultimo Post: 03-01-2010, 01:13
  4. dll e gestione memoria
    Da gheldrya nel forum Altri linguaggi e strumenti
    Risposte: 4
    Ultimo Post: 24-05-2009, 19:48
  5. Stato della memoria del CD
    Da luca_vb nel forum Visual Basic .Net
    Risposte: 7
    Ultimo Post: 21-03-2008, 15:08