neuro_m.c

嵌入式RMON,RMON为Remote monitor的缩写,基于SNMP为网络提供主动监控及错误告警,智能交换路由必备协议

				}
			case SNMP_VALID:
				switch (obj->Syntax.LngInt)
				{
				case SNMP_INVALID:	    
					if (NeuroCStop(data) == TRUE)
					{
                        DelNeuroData(data);
						if (MibRemove(obj, &NeuroDataInstance, idlen, 1) == TRUE)
                        {
                            RunningNrNetworks--;
                            TotalNrNetworks--;
		                    MESSAGE(MODULE, NEURO_DESTROY);
							return SNMP_NOERROR;
                        }
					}
					return SNMP_GENERROR;
                case SNMP_VALID:
                    return SNMP_NOERROR;
				default:
					return SNMP_BADVALUE;
				}
			}
		}
	}
    return SNMP_GENERROR;
}


VOID NeuroMCalcCallback(TIMER_DESCR *timer, ULONG now, VOID *param)
{      
NeuroData* net = param;
FLOAT error;
BOOLEAN update;

	if (net->In != NULL && net->Out != NULL && net->Target != NULL)
	{
		if (net->Train == NEURO_BATCH && net->BatchIndex == net->GrantedSize)
			net->BatchIndex = 0;

		if (NeuroMib2Neuron(net, net->InputData, net->NrNeurons[0], net->InputBatch, net->In) == FALSE)
		{
			ERROR(MODULE, NEURO_NOINPUT);
			return;
		}

		if (net->Train != NEURO_NOTRAIN)
        {
            if (NeuroMib2Neuron(net, net->TargetData, net->NrNeurons[net->NrLayers-1], net->TargetBatch, net->Target) == FALSE)
		    {
			    ERROR(MODULE, NEURO_NOTARGET);
			    return;
		    }
            NeuronInOutputCpy(net->Out, net->Target, net->NrNeurons[net->NrLayers-1]);
        }
		else
        {
            NeuroInitOutput(net->NrNeurons[net->NrLayers-1], net->Out);
        }

		if (net->Train != NEURO_BATCH || net->BatchIndex+1 == net->GrantedSize)
			update = TRUE;
		else
			update = FALSE;

		if (CalcNeuronNet(net->Net, 
			      net->In, net->NrNeurons[0], 
			      net->Out, net->NrNeurons[net->NrLayers-1],
			      net->Train != NEURO_NOTRAIN, update,
			      net->LearningRate, net->Momentum) != NEURO_OK)
		{
			ERROR(MODULE, NEURO_CALCERR);
			return;
		}

		if (NeuroNeuron2Mib(net->Out, net->NrNeurons[net->NrLayers-1], net->TargetData, net->OutputValue) == FALSE)
		{
			ERROR(MODULE, NEURO_NORESULT);
			return;
		}
						  
		if (net->Train != NEURO_NOTRAIN)
		{
			if (CalcNeuronNetError(net->Net, 
					   			   net->Target, net->NrNeurons[net->NrLayers-1], 
					   			   &error) != NEURO_OK)
			{
				ERROR(MODULE, NEURO_CALCERR);
				return;
			}

			net->BatchError += error;
			if (update == TRUE || net->BatchSize < net->GrantedSize)
			{
				net->Error = net->BatchError;
				if (net->BatchSize == net->GrantedSize)
					net->BatchError = 0;
			}

			net->TrainSteps++;
		}
		else
		{
			net->Error = 0;
		}
		
		if (NeuroCheckThresholds(net) == FALSE)
			ERROR(MODULE, NEURO_THRESHOLD);
		
		if (net->Train == NEURO_BATCH && net->BatchSize < net->GrantedSize)
			net->BatchSize++;

		if (net->Train == NEURO_BATCH && net->GrantedSize > 0)
			net->BatchIndex++;

		net->TotalSteps++;
	}
    else
    {
        FATAL(MODULE, NEURO_ALLOCATE);
    }
 
    return;
}

		    
BOOLEAN NeuroMib2Neuron(NeuroData* net, InOutData* mibinout, LONG n, InOutBatch *batch, InOutput* inout)
{	 						  
SNMP_OBJECT obj = { SNMP_PDU_GET, { NMIB_BASE }, NMIB_BASELEN, SNMP_INTEGER, SNMP_VALID };
FLOAT value, tmpval;
LONG i, s;

	for (i = 0; i < n; i++)
	{			 
		if (net->Train == NEURO_RETRAIN && net->GrantedSize == 0)
		{
			/* just use already available data */
			inout[i].value = NeuronValue((mibinout[i].TheValue-mibinout[i].MinValue)/(mibinout[i].MaxValue-mibinout[i].MinValue));
		}
		else
		{
			if ((net->Train == NEURO_BATCH || net->Train == NEURO_RETRAIN) && 
				net->GrantedSize > 0 && net->BatchSize == net->GrantedSize)
			{
				mibinout[i].TheValue = batch[net->BatchIndex*n+i].TheValue;
			}
			else
			{
				memcpy(obj.Id, mibinout[i].Id, (obj.IdLen = mibinout[i].IdLen)*sizeof(mibinout[i].Id[0]));
				if (MibRequest(&obj) != SNMP_NOERROR)
					return FALSE;
	
				inout[i].inoutnr = i;		 
				switch (obj.Type)
				{
				case SNMP_INTEGER:
					value = (FLOAT)obj.Syntax.LngInt;
					break;
				case SNMP_COUNTER:
				case SNMP_GAUGE:
				case SNMP_TIMETICKS:
					value = (FLOAT)obj.Syntax.LngUns;
					break;
				default:	     
					ERROR(MODULE, NEURO_WRONGTYPE);
					return FALSE;
				}
				
				if (mibinout[i].AverageMethod != SIMPLE_DIFF && mibinout[i].AverageMethod != SIMPLE_VALUE)
					for (s = 1; s < mibinout[i].AverageSteps; s++)
						mibinout[i].Value[s] = mibinout[i].Value[s-1];
					
	            tmpval = value;
	
				switch (mibinout[i].AverageMethod)
				{    
				case SIMPLE_DIFF: 
					value -= mibinout[i].PrevValue;
				case SIMPLE_VALUE:		       
					mibinout[i].Value[0] = value;
					mibinout[i].TheValue = value;
					break;
				case MEAN_DIFF:
					value -= mibinout[i].PrevValue;
				case MEAN_VALUE:
					mibinout[i].Value[0] = value;
					mibinout[i].TheValue = NeuroMean(mibinout[i].Value, mibinout[i].AverageSteps);
					break;
				case HARMONIC_DIFF:
					value -= mibinout[i].PrevValue;
				case HARMONIC_VALUE:
					mibinout[i].Value[0] = value;
					mibinout[i].TheValue = NeuroHarmonic(mibinout[i].Value, mibinout[i].AverageSteps);
					break;
				}
	            
	            mibinout[i].PrevValue = tmpval;
				
				if (net->Train == NEURO_BATCH && net->GrantedSize > 0)
					batch[net->BatchIndex*n+i].TheValue = mibinout[i].TheValue;
			}

		 	inout[i].value = NeuronValue((mibinout[i].TheValue-mibinout[i].MinValue)/(mibinout[i].MaxValue-mibinout[i].MinValue));
		}
	}	 
    
	return TRUE;
}


FLOAT NeuroMean(FLOAT value[], LONG nrvalues)
{				      
FLOAT result = 0;
LONG i;

	for (i = 0; i < nrvalues; i++)
		result += value[i];
	return result/nrvalues;
}


FLOAT NeuroHarmonic(FLOAT value[], LONG nrvalues)
{				      
FLOAT result = 0;
LONG i;

	for (i = 0; i < nrvalues; i++)
		if (value[i] != 0)
			result += 1.0/value[i];
	return nrvalues/(result != 0 ? result : 1);
}


BOOLEAN NeuroNeuron2Mib(InOutput* inout, LONG n, InOutData* iodata, FLOAT* out)
{
LONG i;

	for (i = 0; i < n; i++)
		out[inout[i].inoutnr] = NeuronRealValue(inout[i].value)*(iodata[i].MaxValue-iodata[i].MinValue)+iodata[i].MinValue;
    return TRUE;
}


BOOLEAN NeuroInitOutput(LONG n, InOutput* inout)
{
LONG i;

    for (i = 0; i < n; i++)
        inout[i].inoutnr = i;
    return TRUE;
}


BOOLEAN NeuroCheckThresholds(NeuroData* data)
{			
InOutData* datasource;
LONG l, n;   
FLOAT value;
BOOLEAN trap;

	for (l = 0; l < data->NrLayers; l += data->NrLayers-1)
	{				
		for (n = 0; n < data->NrNeurons[l]; n++)
		{			    
			if (l > 0)
			{
				datasource = &data->TargetData[n];
				if (data->Train != NEURO_NOTRAIN)
					value = datasource->TheValue;
				else
					value = data->OutputValue[n];
			}
			else
			{
				datasource = &data->InputData[n];    
				value = datasource->TheValue;
			}
	
			trap = FALSE;
			
			switch (datasource->ThresholdCheck)
			{	      
			case LESS_THAN:
				if (value < datasource->ThresholdValue[0])
					trap = TRUE;
				break;
			case GREATER_THAN:
				if (value > datasource->ThresholdValue[0])
					trap = TRUE;
				break;
			case IN_RANGE:
				if (value > datasource->ThresholdValue[0] &&
				    value < datasource->ThresholdValue[1])
					trap = TRUE;
				break;
			case OUT_RANGE:
				if (value < datasource->ThresholdValue[0] &&
				    value > datasource->ThresholdValue[1])
					trap = TRUE;
				break;
			case EQUAL:
				if (value == datasource->ThresholdValue[0])
					trap = TRUE;
				break;
			case NOT_EQUAL:
				if (value != datasource->ThresholdValue[0])
					trap = TRUE;
				break;
			case NO_THRESHOLD:
			default:
				break;
			}
				
  			if (trap == TRUE)
            {
    			if (datasource->Trap)
					AgentSendTrap(datasource->TrapComm, datasource->TrapCommLen,
						    SNMP_TRAP_ENTSPECIFIC, TRAP_SPECIFIC_NEUROTHRESHOLD, NULL, 0);
            }
		}
	}
    
	return TRUE;
}


BOOLEAN NeuroAllocBatch(NeuroData *data, LONG size, BOOLEAN reset)
{
InOutBatch *input = NULL, *target = NULL;
LONG dsize;

	data->BatchSize = 0;
	data->BatchIndex = 0;
	
	if (size <= 0)
	{
		FREE(data->InputBatch);
		FREE(data->TargetBatch);
		data->InputBatch = NULL;
		data->TargetBatch = NULL;
		data->GrantedSize = 0;
		return TRUE;
	}
	
	if ((dsize = size/10) == 0)
		dsize = 1;
		
	if (data->GrantedSize > size || reset == TRUE)
	{
		FREE(data->InputBatch);
		FREE(data->TargetBatch);
		data->InputBatch = NULL;
		data->TargetBatch = NULL;
		data->GrantedSize = 0;
	}
	
	while (size > 0)
	{
		input = NewInOutBatch(size*data->NrNeurons[0]);
		target = NewInOutBatch(size*data->NrNeurons[data->NrLayers-1]);
		if (input != NULL && target != NULL)
			break;
		else
		{
			FREE(input);
			FREE(target);
			size -= dsize;
		}
	}
	
	if (size > data->GrantedSize)
	{
		FREE(data->InputBatch);
		FREE(data->TargetBatch);
		data->InputBatch = input;
		data->TargetBatch = target;
		data->GrantedSize = size;
	}
	else
	{
	 	FREE(input);
		FREE(target);
	}
	
	return TRUE;
}

		
WORD NeuroSetId(SNMP_OBJECT* obj, WORD idc, WORD indexsize, LONG c, LONG l, LONG n, LONG i)
{
LONG baseindex[] = { NMIB_BASE, 0, 0, 0 };
			      
	switch (idc)
	{
    case NMIB_NRNETWORKS:
		NEUROSETID(baseindex, NMIB_NRNETWORKSID);
        break;
    case NMIB_INDEX:
		NEUROSETID(baseindex, NMIB_INDEXID);
        break;
    case NMIB_NRLAYERS:
		NEUROSETID(baseindex, NMIB_NRLAYERSID);
        break;
    case NMIB_NETREFRESH:
		NEUROSETID(baseindex, NMIB_NETREFRESHID);
        break;
    case NMIB_TRAIN:
		NEUROSETID(baseindex, NMIB_TRAINID);
        break;
    case NMIB_REQSIZE:
		NEUROSETID(baseindex, NMIB_REQSIZEID);
        break;
    case NMIB_GRANTSIZE:
		NEUROSETID(baseindex, NMIB_GRANTSIZEID);
        break;
    case NMIB_BATCHSIZE:
		NEUROSETID(baseindex, NMIB_BATCHSIZEID);
        break;
    case NMIB_LRATE:
		NEUROSETID(baseindex, NMIB_LRATEID);
        break;
    case NMIB_MOMENTUM:
		NEUROSETID(baseindex, NMIB_MOMENTUMID);
        break;
    case NMIB_TOTALSTEPS:
		NEUROSETID(baseindex, NMIB_TOTALSTEPSID);
        break;
    case NMIB_TRAININGSTEPS: 
		NEUROSETID(baseindex, NMIB_TRAININGSTEPSID);
        break;
    case NMIB_ERROR:
		NEUROSETID(baseindex, NMIB_ERRORID);
        break;
    case NMIB_OWNER:
		NEUROSETID(baseindex, NMIB_OWNERID);
        break;
    case NMIB_STATUS: 
		NEUROSETID(baseindex, NMIB_STATUSID);
        break;
    case NMIB_NRNEURONS: 
		NEUROSETID(baseindex, NMIB_NRNEURONSID);
        break;
    case NMIB_DATASRC:
		NEUROSETID(baseindex, NMIB_DATASRCID);
        break;
    case NMIB_DATASRCMAX:
		NEUROSETID(baseindex, NMIB_DATASRCMAXID);
        break;
    case NMIB_DATASRCMIN:
		NEUROSETID(baseindex, NMIB_DATASRCMINID);
        break;
    case NMIB_DATASRCAVERAGEMETHOD:
		NEUROSETID(baseindex, NMIB_DATASRCAVERAGEMETHODID);
        break;
    case NMIB_DATASRCSTEPS: 
		NEUROSETID(baseindex, NMIB_DATASRCSTEPSID);
        break;
    case NMIB_DATASRCTRAP:
		NEUROSETID(baseindex, NMIB_DATASRCTRAPID);
        break;
    case NMIB_DATASRCTRAPCOMM:
		NEUROSETID(baseindex, NMIB_DATASRCTRAPCOMMID);
        break;
    case NMIB_DATASRCTHRESHOLDCHECK:
		NEUROSETID(baseindex, NMIB_DATASRCTHRESHOLDCHECKID);
        break;
    case NMIB_DATASRCVALUE:
		NEUROSETID(baseindex, NMIB_DATASRCVALUEID);
        break;
    case NMIB_OUTPUTVALUE:
		NEUROSETID(baseindex, NMIB_OUTPUTVALUEID);
        break;
    case NMIB_DATASRCTHRESHOLDVALUE:
		NEUROSETID(baseindex, NMIB_DATASRCTHRESHOLDVALUEID);
        break;
	}							       
	
	memcpy(obj->Id, baseindex, (obj->IdLen = sizeof(baseindex))*sizeof(baseindex[0]));
    while (obj->Id[obj->IdLen-1] == 0)
        obj->IdLen--;
	
	switch (indexsize)
	{
	case NMIB_IOFFSET:				     
		if (i > 0)
			obj->Id[obj->IdLen-1+NMIB_IOFFSET] = i;
	case NMIB_NOFFSET:
		if (n > 0)
			obj->Id[obj->IdLen-1+NMIB_NOFFSET] = n;
	case NMIB_LOFFSET:
		if (l > 0)
			obj->Id[obj->IdLen-1+NMIB_LOFFSET] = l;
	case NMIB_COFFSET:
		if (c > 0)
			obj->Id[obj->IdLen-1+NMIB_COFFSET] = c;
    default:
        break;
	}	
	return SNMP_NOERROR;
}


WORD MibName2ID(LONG* id, CHAR* name, UINT* n)
{
LONG tmp;
CHAR *p;
CHAR name2[10*SNMP_SIZE_BUFINT];

		if (name == NULL)
			return SNMP_NOSUCHNAME;
			
		strcpy(name2, name);
		
        *n = 0;

        p = strtok(name2, ".");
        while (p != NULL)
        {
                if (*n < SNMP_SIZE_BUFINT && (tmp = atoi(p)) != 0)
                        id[*n++] = tmp;
                else
                        return SNMP_NOSUCHNAME;
                p = strtok(NULL, ".");
        }

        return SNMP_NOERROR;
}


WORD MibID2String(const LONG* id, UINT nr, CHAR* name, INT maxlen)
{
INT ni, n;
UINT i;
CHAR tmp[20];	/*  ample space for 1 number and a '.'  */

	ni = 0;
	name[0] = '\0';

	sprintf(tmp, "%ld%n", id[0], &n);	/*  initialize name  */
	if (ni+n > maxlen)
		return 0;
	strcpy(name+ni, tmp);
	ni += n;

	for (i = 1; i < nr; i++)
	{
		sprintf(tmp, ".%ld%n", id[i], &n);
		if (ni+n > maxlen)
			return 0;
		strcpy(name+ni, tmp);
		ni += n;
	}

	return ni;
}