Hjelp til å forstå valgrind output

[Vikdal]

Heisann

Jeg jobber med et C++ program som jeg synes bruker mye mer ram enn hva det burde. Siden jeg fortsetter på koden som noen andre har skrevet tidligere kompilerte jeg det med -g option og kjørte det gjennom valgrind. Her kommer det frem at det er store minnetap.

 

Jeg har sett litt på koden, og noen tutorials for å forstå output'en, men jeg er veldig usikker på akkurat hva jeg må gjøre for å rette opp i feilen. Jeg har forstått såpass at det for hver new/new[] må finnes en delete/delete[]. Disse må være innenfor samme scope ?

 

Håper derfor noen kan gi meg en pekepinn på hva som er galt. Jeg får et par "blokker" med feil, men jeg tenkte at dersom jeg fikk litt hjelp til å rette EN så klarer jeg helt sikkert resten selv.

 

Her er funksjonen det gjelder (har markert linje 1901):

Klikk for å se/fjerne innholdet nedenfor

void init_indexes_old()
{
 cout << "Running SINGLE-threaded version of init_indexes: init_indexes_old" << endl;
 // Init indexes, primary keys, fetch and insert values
 uint_t pos = 0;
 RelId last_rel = 0;
 types idx_type;
 cout << "Number of indexes to create" << num_idxs << endl;

 for (AttrId aid = 1; aid <= num_idxs; aid++) {
idx_type = dbschema->get_attr_type(aid);
switch(idx_type){
  case INT:
	indexes[aid] = (Index*)(new IDX_i32_t);
	break;
  case L_LONG:
	indexes[aid] = (Index*)(new IDX_i64_t);
	break;
  case FLOAT:
	indexes[aid] = (Index*)(new IDX_f32_t);
	break;
  case DOUBLE:
	indexes[aid] = (Index*)(new IDX_f64_t);
	break;
  case CHAR:
  case TEXT:
	indexes[aid] = (Index*)(new IDX_str_t);
	break;
}
indexes[aid]->attr_type = idx_type;
indexes[aid]->rel_id	= dbschema->attr_id2rel_id(aid);
indexes[aid]->size 		= 
  dbschema->get_row_cnt(indexes[aid]->rel_id);
indexes[aid]->prim_num  = 1; // A relation has only one primary key
indexes[aid]->is_intermediate = false;
if (indexes[aid]->rel_id > last_rel) { 
  last_rel = indexes[aid]->rel_id; 
  pos = 0;
}
indexes[aid]->attr_pos  = pos++;
//cout << "aid: " << aid << "--> " << indexes[aid]->rel_id << endl;
 }

 AttrId aid_start = 1;
 union value_types db_value;
 PrimKey** tmp_primkey;
 uint_t num_attr;
 uint_t num_rows;
 int j;


 for (RelId rid = 1; rid <= num_rels; rid++) {
dbschema->set_rid_being_indexed(rid); // added for swap
num_rows = dbschema->get_row_cnt(rid);
num_attr = dbschema->get_attr_cnt(rid);
for(AttrId aid = aid_start; aid < num_attr + aid_start; aid++){
  indexes[aid]->init_tmp_primkeys(num_rows);
  indexes[aid]->init_tmp_attr_list(num_rows);
}

int dots = num_rows / 10;
dots = dots < 1 ? 1 : dots;

/* Getting attribute values: */
  cout << "Building indexes for 33[1m" 
<< dbschema->rel_id2rel_name(rid) << "33[0m: " << flush;

if (dbfrontend->get_attr_values(dbschema->rel_id2rel_name(rid))) {
  for (int i = 0; dbfrontend->advance(); i++) { // for hver rad i relasjonen
if (i % dots == 0) cout << '.' << flush;
			tmp_primkey = new PrimKey*[1];
	tmp_primkey[0] = new PrimKey();
	tmp_primkey[0]->rel_id = rid;
	tmp_primkey[0]->num = dbschema->get_num_pkeys(rid);
	tmp_primkey[0]->item = new PrimKeyItem*[tmp_primkey[0]->num];
	tmp_primkey[0]->inv = new union value_types*[num_attr];	/*** DETTE ER LINJE 1901 ***/
	j = 0;		
for (AttrId aid = aid_start; aid < num_attr + aid_start; aid++) {

  tmp_primkey[0]->inv[indexes[aid]->attr_pos] = new union value_types;

  /* Henter ut den faktiske verdien */
  db_value = 
	dbfrontend->get_value(dbschema->attr_id2attr_name(aid),
			  indexes[aid]->attr_type);


  switch(indexes[aid]->attr_type){
	case CHAR:
	case TEXT:
		CAST_str_t(indexes[aid])->tmp_attr_list[i] = db_value.strval;
	tmp_primkey[0]->inv[indexes[aid]->attr_pos]->strval = db_value.strval;
	//cout << "Fikk denne verdien: " << db_value.strval << endl;
	break;
	case INT:
		CAST_i32_t(indexes[aid])->tmp_attr_list[i] = db_value.i32val;
	tmp_primkey[0]->inv[indexes[aid]->attr_pos]->i32val = db_value.i32val;
	break;
	case L_LONG:
	  CAST_i64_t(indexes[aid])->tmp_attr_list[i] = db_value.i64val;
	tmp_primkey[0]->inv[indexes[aid]->attr_pos]->i64val = db_value.i64val;
	break;
	case FLOAT:
	  CAST_f32_t(indexes[aid])->tmp_attr_list[i] = db_value.f32val;
	  tmp_primkey[0]->inv[indexes[aid]->attr_pos]->f32val = db_value.f32val;
	break;
	case DOUBLE:
	  CAST_f64_t(indexes[aid])->tmp_attr_list[i] = db_value.f64val;
	  tmp_primkey[0]->inv[indexes[aid]->attr_pos]->f64val = db_value.f64val;
	break;
  }


  if(dbschema->is_primary_key(rid, aid)){
	tmp_primkey[0]->item[j] = new PrimKeyItem();
		tmp_primkey[0]->item[j]->pt = tmp_primkey[0]->inv[indexes[aid]->attr_pos];
		j++;
	  }
}

indexes[aid_start]->tmp_primkeys[i] = tmp_primkey;
for(AttrId aid = aid_start + 1; aid < num_attr + aid_start; aid++){
  indexes[aid]->tmp_primkeys[i] = new PrimKey*[1];
  indexes[aid]->tmp_primkeys[i][0] = tmp_primkey[0];
	}

  }//END for hver rad  i relasjonen

  // load data
  for(AttrId aid = aid_start; aid < num_attr + aid_start; aid++){
	  //cout << "Loading data for aid: " << aid << endl;
	indexes[aid]->load_data(num_rows, false);
	indexes[aid]->delete_tmp_attr_list();
	indexes[aid]->delete_tmp_primkeys();
  }
}
else {
  assert(false);
}

	dbschema->set_rel_name_as_indexed(dbschema->rel_id2rel_name(rid));
cout << " [ 33[32mdone33[0m ]" << endl;

aid_start += num_attr;

/* Check if swapping is in progress */
while(dbschema->is_swapping()){
	//cout << "wait for swap" << endl;
	sleep(2);
}
 }
 cout << "*** Index creation done ***" << endl;	
}

 

og her er valgrind output'en

Klikk for å se/fjerne innholdet nedenfor

==13232== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 39 from 2)
==13232== malloc/free: in use at exit: 19,411,891 bytes in 3,461,878 blocks.
==13232== malloc/free: 10,427,085 allocs, 6,965,207 frees, 227,217,564 bytes allocated.
==13232== For counts of detected errors, rerun with: -v
==13232== searching for pointers to 3,461,878 not-freed blocks.
==13232== checked 494,824 bytes.
==13232== 
==13232== 
==13232== 2,769,412 bytes in 692,353 blocks are definitely lost in loss record 23 of 26
==13232==	at 0x4004BBE: operator new[](unsigned) (vg_replace_malloc.c:197)
==13232==	by 0x8066CB2: init_indexes_old() (csb_tree_indexes.cpp:1896)
==13232==	by 0x806B1C1: IndexManager::build_indexes() (csb_tree_indexes.cpp:2029)
==13232==	by 0x80520B5: Rindex::Rindex(int, bool, std::string, std::string, std::string) (executor.hpp:32)
==13232==	by 0x804B26D: main (rindex-bin.cpp:318)
==13232== 
==13232== 
==13232== 2,769,432 bytes in 692,358 blocks are definitely lost in loss record 24 of 26
==13232==	at 0x4004BBE: operator new[](unsigned) (vg_replace_malloc.c:197)
==13232==	by 0x8066CFD: init_indexes_old() (csb_tree_indexes.cpp:1900)
==13232==	by 0x806B1C1: IndexManager::build_indexes() (csb_tree_indexes.cpp:2029)
==13232==	by 0x80520B5: Rindex::Rindex(int, bool, std::string, std::string, std::string) (executor.hpp:32)
==13232==	by 0x804B26D: main (rindex-bin.cpp:318)
==13232== 
==13232== 
==13232== 5,538,872 bytes in 1,384,718 blocks are definitely lost in loss record 25 of 26
==13232==	at 0x4004BBE: operator new[](unsigned) (vg_replace_malloc.c:197)
==13232==	by 0x8066C55: init_indexes_old() (stl_vector.h:462)
==13232==	by 0x806B1C1: IndexManager::build_indexes() (csb_tree_indexes.cpp:2029)
==13232==	by 0x80520B5: Rindex::Rindex(int, bool, std::string, std::string, std::string) (executor.hpp:32)
==13232==	by 0x804B26D: main (rindex-bin.cpp:318)
==13232== 
==13232== 
==13232== 8,308,272 bytes in 692,356 blocks are definitely lost in loss record 26 of 26
==13232==	at 0x4004BBE: operator new[](unsigned) (vg_replace_malloc.c:197)
==13232==	by 0x8066D13: init_indexes_old() (csb_tree_indexes.cpp:1901)
==13232==	by 0x806B1C1: IndexManager::build_indexes() (csb_tree_indexes.cpp:2029)
==13232==	by 0x80520B5: Rindex::Rindex(int, bool, std::string, std::string, std::string) (executor.hpp:32)
==13232==	by 0x804B26D: main (rindex-bin.cpp:318)
==13232== 
==13232== LEAK SUMMARY:
==13232==	definitely lost: 19,386,024 bytes in 3,461,786 blocks.
==13232==	indirectly lost: 120 bytes in 10 blocks.
==13232==	  possibly lost: 80 bytes in 12 blocks.
==13232==	still reachable: 25,667 bytes in 70 blocks.
==13232==		 suppressed: 0 bytes in 0 blocks.
==13232== Reachable blocks (those to which a pointer was found) are not shown.
==13232== To see them, rerun with: --show-reachable=yes

 

Sier takk til all hjelp

Endret 20. april 2008 av Dotten
Lagt koden i skjul for bedre oversikt.

[teflonpanne]

Du trenger ikke putte delete/delete[] i samme scope nei, men når du ikke trenger noe du har new/new[]'a lenger så deleter du det. I programmet over så allokerer du minne for Primkey'er, og valgrind prøver antakeligvis å si at de ikke blir deletet. Det er opp til deg hvor du vil frigjøre minnet..

Endret 20. april 2008 av teflonpanne

[Vikdal]

Takk for svar teflonpanne

Skal se litt på det og prøve meg litt frem

 

Kommer med flere spørsmål dersom de dukker opp