HELP!!! exception: std::bad_alloc at memory location dbgheap.c

[aprillate]

Hello all!
I am programming a genetic algorithm.
Normally, i use only two populations at each iteration, (the same objects).
The memory usage grows with the number of iterations, although I'm only using the same objects.

if I consider like 10000 iterations, no problem occurs (only i didn't get near the optimum). Above that, i get this unhandled exception:
exception: std::bad_alloc at memory location dbgheap.c

I am suspecting two functions in my code (I can't copy/paste all of it) to be the cause of the error. but i really don't know what's the deal!

can you please help me!

I am posting the functions in replies because of the length limit.

structs used:
-------------
struct FD_C
{
int FD_index;
int C; //card type
~FD_C(){};
};
struct Period
{
bool vacancy; // true: vacant, false: busy
int nb_FD;
vector <FD_C> fd_c;
~Period(){};
};
struct WFD //Usage of wavelengths over SPs. contains Fragment demands (FD) using a certain lambda
{
int lambda;
int nb_FD;
vector <FD_C> FD_table; // indices of FDs
Period *Emploi_du_temps;
~WFD(){};

};
struct SP_monitor // contains FDs carried by used lambdas over a certain SP

{
int SP;
int nb_lambda; // how many lambdas are used over a certain SP
vector <WFD> WFD_monitor;
~SP_monitor(){
};
};
struct Monitor //contains all used SPs, with their usage (which FD is using which SP)
{
int nb_SP;
vector<SP_monitor> sp_monitor;
~Monitor(){};
};



struct lambda_usage
{
public:
int lambda;
//vector<int> time_usage[T];
bool *time_usage;
lambda_usage(const lambda_usage& arg) : lambda(arg.lambda)
{
time_usage=new bool[T];
for (int i=0;i<T;i++)
{
time_usage[i]=arg.time_usage[i];
//cout<<arg.time_usage[i]<<" "<<time_usage[i]<<endl;
}
}
lambda_usage()
{
time_usage=new bool[T];
lambda=-1;
for (int i=0;i<T;i++)
{
time_usage[i]=true;
}
}
void write()
{
cout<<"lambda = "<<lambda<<endl;
for (int i=0;i<T;i++)
{
cout<<"t= "<<i<<" : "<<time_usage[i]<<endl;
}
cout<<endl;

}
~lambda_usage()
{
delete [] time_usage;
};
};
struct link_usage
{
int link;
vector<lambda_usage>lambda_table;
~link_usage(){};
};

struct period_monitor
{
public:
int **tx;// contains 1 if it's used to transmit a signal, -1 if its corresponding receiver is receiving and it's not transmitting at the same time, 0 otherwise1
int **rx;
period_monitor()
{
tx=new int*[C];
rx=new int*[C];
for(int i=0;i<C;i++)
{
tx[i]=new int[W];
rx[i]=new int[W];
}
};
~period_monitor()
{
for(int i=0;i<C;i++)
{
delete []tx[i];
delete []rx[i];

}
delete []tx;
};
};

[aprillate]

first function:
----------------
void Fill_Monitor(vector<Gene>& Chromosome)
{
int i,j,k, t;
int nb_sp_utile, sp, sp_in_solution, lambda, card_type,CWA,lambda_in_sp_monitor;

SP_monitor sp_monitor;
WFD wfd_monitor;
FD_C fdc;

wfd_monitor.Emploi_du_temps=new Period[T];
for (k=0; k<T;k++)
{
wfd_monitor.Emploi_du_temps[k].vacancy=true;
wfd_monitor.Emploi_du_temps[k].nb_FD=0;
}
solution.nb_SP=0;
for (i=0; i<Chromosome.size();i++)
{

nb_sp_utile=Chromosome[i].nb_useful_SP;
for (j=0; j<nb_sp_utile;j++)
{


wfd_monitor.FD_table.clear();
sp_monitor.WFD_monitor.clear();
lambda=Chromosome[i].CWA[j]%W;
card_type=Chromosome[i].CWA[j]/W;
sp=layout_vector[Layout_container[demand_vector[FD_table[i]].src_node][demand_vector[FD_table[i]].dest_node].Layout_Table[Chromosome[i].layout]].Subpath[j];
sp_in_solution=sp_exists_in_monitor(sp,solution);
if (sp_in_solution==-1)
{
for (k=0; k<T;k++)
{
wfd_monitor.Emploi_du_temps[k].vacancy=true;
wfd_monitor.Emploi_du_temps[k].nb_FD=0;
}

fdc.C=card_type;
fdc.FD_index=i;
wfd_monitor.lambda=lambda;
wfd_monitor.nb_FD=1;
wfd_monitor.FD_table.push_back(fdc);
sp_monitor.nb_lambda=1;
sp_monitor.SP=sp;
for (t=demand_vector[FD_table[i]].setup;t<=demand_vector[FD_table[i]].teardown;t++)
{
wfd_monitor.Emploi_du_temps[t].vacancy=false;
wfd_monitor.Emploi_du_temps[t].nb_FD++;
wfd_monitor.Emploi_du_temps[t].fd_c.push_back(fdc);
}

sp_monitor.WFD_monitor.push_back(wfd_monitor);

solution.sp_monitor.push_back(sp_monitor);
solution.nb_SP++;

}
else
{
for (k=0; k<T;k++)
{
wfd_monitor.Emploi_du_temps[k].vacancy=true;
wfd_monitor.Emploi_du_temps[k].nb_FD=0;
}
lambda_in_sp_monitor=lambda_exists_in_sp_monitor(lambda,solution,sp_in_solution);
if(lambda_in_sp_monitor==-1)
{
fdc.C=card_type;
fdc.FD_index=i;
wfd_monitor.lambda=lambda;
wfd_monitor.nb_FD=1;
wfd_monitor.FD_table.push_back(fdc);
for (t=demand_vector[FD_table[i]].setup;t<=demand_vector[FD_table[i]].teardown;t++)
{
wfd_monitor.Emploi_du_temps[t].vacancy=false;
wfd_monitor.Emploi_du_temps[t].nb_FD++;
wfd_monitor.Emploi_du_temps[t].fd_c.push_back(fdc);
}

solution.sp_monitor[sp_in_solution].WFD_monitor.push_back(wfd_monitor);

solution.sp_monitor[sp_in_solution].nb_lambda++;



}
else
{
fdc.C=card_type;
fdc.FD_index=i;
solution.sp_monitor[sp_in_solution].WFD_monitor[lambda_in_sp_monitor].FD_table.push_back(fdc);
for (t=demand_vector[FD_table[i]].setup;t<=demand_vector[FD_table[i]].teardown;t++)
{
solution.sp_monitor[sp_in_solution].WFD_monitor[lambda_in_sp_monitor].Emploi_du_temps[t].vacancy=false;
solution.sp_monitor[sp_in_solution].WFD_monitor[lambda_in_sp_monitor].Emploi_du_temps[t].nb_FD++;
solution.sp_monitor[sp_in_solution].WFD_monitor[lambda_in_sp_monitor].Emploi_du_temps[t].fd_c.push_back(fdc);
}

solution.sp_monitor[sp_in_solution].WFD_monitor[lambda_in_sp_monitor].nb_FD++;

}
}
}
}

}

Second function:
---------------------



int nodes_monitor_power()
{

vector<int> cards;
period_monitor monitor[N][T];
bool found;

int s,l,d,c,t, n,card, i,sum,N_cards[N][C],card_time,power=0;
for(t=0;t<T;t++)
{
for(n=0;n<N;n++)
{
for(c=0;c<C;c++)
{
for (l=0;l<W;l++)
{
monitor[n][t].tx[c][l]=0;
monitor[n][t].rx[c][l]=0;
}

}
}
}

for(s=0; s<solution.nb_SP;s++)
{
for(l=0;l<solution.sp_monitor[s].nb_lambda;l++)
{
for(t=0;t<T;t++)
{
if(!solution.sp_monitor[s].WFD_monitor[l].Emploi_du_temps[t].vacancy)
{
sum=0;
cards.clear();
for(d=0;d<solution.sp_monitor[s].WFD_monitor[l].Emploi_du_temps[t].nb_FD;d++)
{
card=solution.sp_monitor[s].WFD_monitor[l].Emploi_du_temps[t].fd_c[d].C;
found=false;
for(c=0;c<cards.size();c++)
{
if(cards[c]==card)
{
found=true;
c=cards.size();
}
}
if(!found)
{
if((monitor[sp_vector[solution.sp_monitor[s].SP].Src_Node][t].tx[card][solution.sp_monitor[s].WFD_monitor[l].lambda]==1)||(monitor[sp_vector[solution.sp_monitor[s].SP].Dst_Node][t].rx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==1))
return (2*INFINITY);
else
{
monitor[sp_vector[solution.sp_monitor[s].SP].Src_Node][t].tx[card][solution.sp_monitor[s].WFD_monitor[l].lambda]=1;
if(monitor[sp_vector[solution.sp_monitor[s].SP].Src_Node][t].rx[card][solution.sp_monitor[s].WFD_monitor[l].lambda]==0)
monitor[sp_vector[solution.sp_monitor[s].SP].Src_Node][t].rx[card][solution.sp_monitor[s].WFD_monitor[l].lambda]=-1;
monitor[sp_vector[solution.sp_monitor[s].SP].Dst_Node][t].rx[card][solution.sp_monitor[s].WFD_monitor[l].lambda]=1;
if(monitor[sp_vector[solution.sp_monitor[s].SP].Dst_Node][t].tx[card][solution.sp_monitor[s].WFD_monitor[l].lambda]==0)
monitor[sp_vector[solution.sp_monitor[s].SP].Dst_Node][t].tx[card][solution.sp_monitor[s].WFD_monitor[l].lambda]=-1;

}

sum=0;
for(c=0;c<C;c++)
{
if((monitor[sp_vector[solution.sp_monitor[s].SP].Src_Node][t].tx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==1)||(monitor[sp_vector[solution.sp_monitor[s].SP].Src_Node][t].tx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==-1))
sum+=1;
}
if (sum>1)
return (3*INFINITY);
sum=0;
for(c=0;c<C;c++)
{
if((monitor[sp_vector[solution.sp_monitor[s].SP].Src_Node][t].rx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==1)||(monitor[sp_vector[solution.sp_monitor[s].SP].Src_Node][t].rx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==-1))
sum+=1;
}
if (sum>1)
return (4*INFINITY);
sum=0;
for(c=0;c<C;c++)
{
if((monitor[sp_vector[solution.sp_monitor[s].SP].Dst_Node][t].rx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==1)||(monitor[sp_vector[solution.sp_monitor[s].SP].Dst_Node][t].rx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==-1))
sum+=1;
}
if (sum>1)
return (5*INFINITY);
sum=0;
for(c=0;c<C;c++)
{
if((monitor[sp_vector[solution.sp_monitor[s].SP].Dst_Node][t].tx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==1)||(monitor[sp_vector[solution.sp_monitor[s].SP].Dst_Node][t].tx[c][solution.sp_monitor[s].WFD_monitor[l].lambda]==-1))
sum+=1;
}
if (sum>1)
return (6*INFINITY);

}
}
}
}
}
}
for (n=0;n<N;n++)
{
for (c=0;c<C;c++)
{
N_cards[n][c]=0;
for(t=0;t<T;t++)
{
card_time=0;
for(l=0;l<W;l++)
{
card_time+=abs(monitor[n][t].tx[c][l]);
}
if(card_time>N_cards[n][c])
N_cards[n][c]=card_time;

}

}
}

for(n=0;n<N;n++)
{
for( i=0;i<C;i++)
{
power+=N_cards[n][i]*CP[i];

}

}


cards.clear();
return (power);
}

[kbw]

That's too much unformatted code to work thru, but std::bad_alloc means you've run out of (the default) heap.

[aprillate]

yes, that's what i don't get. functions normally kill their inside variables before being through.
and in my main code, iterations use the same objects. Same two objects!
why is it that memory usage is greater with each iteration! I'm helpless!

[coder777]

Use code tags: [code]Your code[/code]

Besides that missing formatting I see that you use a lot of meaningless letters like C, W, T and so on. Here

~period_monitor()
{
for(int i=0;i<C;i++)
{
delete []tx[i];
delete []rx[i];

}
delete []tx;
};

you forgot to delete[] rx;

But that might not be the reason. This amount of multidimensional arrays might burst the stack.

[aprillate]

yes indeed i forgot delete[] rx;
as for the letters, they are const global variables.

I am trying to see if pushing variables of type WFD into a vector is doing this huge use of memory, because of the pointer. I suspect it's not being freed at the end of execution



struct WFD //Usage of wavelengths over SPs. contains Fragment demands (FD) using a certain lambda
{
int lambda;
int nb_FD;
vector <FD_C> FD_table; // indices of FDs
Period *Emploi_du_temps;
~WFD(){};

};