neuro_c.c

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

/* Beholder RMON ethernet network monitor,Copyright (C) 1993 DNPAP group */
/* See file COPYING 'GNU General Public Licence' for copyright details   */
#include <dnpap.h>
#include <memory.h>
#include <mibsup.h>
#include <mibrqs.h>
#include <string.h>
#include <timer.h>

#include "neuro_d.h"
#include "neuro_e.h"
#include "neuro_k.h"
#include "neuro_c.h"


IMPORT BOOLEAN BeholderStrictRMON;


static CHAR MODULE[] =	"neuroCollector";


static BOOLEAN      NeuroCheckDataSource(NeuroData* data);

static FLOAT*       NewOutputValues(LONG nrouts);
static FLOAT*       ReNewOutputValues(FLOAT* values, LONG nrouts);
static VOID         DelOutputValues(FLOAT* values);



BOOLEAN NeuroCInit(NeuroData* data)
{			    
	data->NrLayers = 3;
	data->NrNeurons[0] = 2;
	data->NrNeurons[1] = 2;
	data->NrNeurons[2] = 1;
	data->NrNeurons[3] = 0;
	data->NrNeurons[4] = 0;

	data->NetRefresh = 10000;
		
    data->Net = NULL;

	data->InputData = NULL;
	data->TargetData = NULL;
	data->OutputValue = NULL;
	
	data->In = NULL;
	data->Out = NULL;
	data->Target = NULL;
	
	data->Train = NEURO_NOTRAIN;

	data->RequestedSize = 0;
	data->GrantedSize = 0;
	data->BatchSize = 0;
	data->BatchIndex = 0;

	data->InputBatch = NULL;
	data->TargetBatch = NULL;
	
	data->LearningRate = (FLOAT)0.1;
	data->Momentum = (FLOAT)0.5;
	
	data->TotalSteps = 0;
	data->TrainSteps = 0;
	
	data->BatchError = 0;
	data->Error = 0;
	
	data->Owner[0] = '\0';
	data->OwnerLen = 0;

	data->Status = SNMP_INVALID;
	
	data->Timer = NULL;
	
	if ((data->InputData = NewInOutData(data->NrNeurons[0])) == NULL)
    {
		ERROR(MODULE, NEURO_ALLOCATE);
        return FALSE;
    }
	if ((data->TargetData = NewInOutData(data->NrNeurons[data->NrLayers-1])) == NULL)
    {
		ERROR(MODULE, NEURO_ALLOCATE);
        return FALSE;
    }

	BooleanSetAllTrue(data->ObjectSet);
	BooleanSetFalse(data->ObjectSet, NEURO_BOOLEAN_OWNER);

	return TRUE;
}


BOOLEAN NeuroCStart(NeuroData* data, TIMER_CALLBACK callback, VOID* param, ULONG msecs)
{			
	if (BeholderStrictRMON && !BooleanCheckAllTrue(data->ObjectSet))
		return FALSE;

	if (NeuroCheckDataSource(data) == FALSE)
	{
		ERROR(MODULE, NEURO_DATASRC);
		return FALSE;
	}
	
	if ((data->Net = NewNeuronNet(0, data->NrLayers, 
				 data->NrNeurons[0], data->NrNeurons[1],
				 data->NrNeurons[2], data->NrNeurons[3],
				 data->NrNeurons[4])) == NULL)
	{
		ERROR(MODULE, NEURO_ALLOCATE);
		return FALSE;
	}	   
	
	if ((data->OutputValue = NewOutputValues(data->NrNeurons[data->NrLayers-1])) == NULL)
    {
		ERROR(MODULE, NEURO_ALLOCATE);
        return FALSE;
    }

	if ((data->In = NewNeuronInOutput(data->NrNeurons[0])) == NULL)
    {
		ERROR(MODULE, NEURO_ALLOCATE);
        return FALSE;
    }

	if ((data->Out = NewNeuronInOutput(data->NrNeurons[data->NrLayers-1])) == NULL)
    {
		ERROR(MODULE, NEURO_ALLOCATE);
        return FALSE;
    }

	if ((data->Target = NewNeuronInOutput(data->NrNeurons[data->NrLayers-1])) == NULL)
    {
		ERROR(MODULE, NEURO_ALLOCATE);
        return FALSE;
    }

	if ((data->Timer = TimerRegister(callback, param, msecs,
				TIMER_FOREVER, TIMER_TYPE_SKIP)) == NULL)
	{
		ERROR(MODULE, NEURO_TIMERREG);
		return FALSE;
	}

	if (data->Train == NEURO_BATCH && data->GrantedSize == 0)
	{
		ERROR(MODULE, NEURO_NOBATCH);
		return FALSE;
	}

    return TRUE;
}


BOOLEAN NeuroCStop(NeuroData* data)
{		    
	TimerRemove(data->Timer);
	
	DelNeuronNet(data->Net);

	DelNeuronInOutput(data->In);	
	DelNeuronInOutput(data->Out);	
	DelNeuronInOutput(data->Target);	

	DelInOutData(data->InputData);
	DelInOutData(data->TargetData);

	DelOutputValues(data->OutputValue);
		    
	DelInOutBatch(data->InputBatch);
	DelInOutBatch(data->TargetBatch);

	return TRUE;
}


BOOLEAN NeuroCheckDataSource(NeuroData* data)
{			
SNMP_OBJECT obj = { SNMP_PDU_GET, { 0, 0 }, 2, SNMP_INTEGER, SNMP_VALID };
LONG l, n;
InOutData* datasource;
	     	     
	for (l = 0; l == 0 || l == data->NrLayers-1; l += data->NrLayers-1)
	{
		for (n = 0; n < data->NrNeurons[l]; n++)
		{
			if (l == 0)
				datasource = &data->InputData[n];
			else	
			if (l == data->NrLayers-1)
				datasource = &data->TargetData[n];
			else         /*  should never happen  */
				datasource = NULL;
				
			if (datasource->IdLen == 0)
				return FALSE;
			else
			{
				memcpy(obj.Id, datasource->Id, 
					(obj.IdLen = datasource->IdLen)*sizeof(obj.Id[0]));
				if (MibRequest(&obj) == SNMP_NOERROR)
				{		     
					switch (obj.Type)
					{
					case SNMP_INTEGER:
        				datasource->PrevValue = (FLOAT)obj.Syntax.LngInt;
						break;
					case SNMP_COUNTER:
					case SNMP_GAUGE:
					case SNMP_TIMETICKS:
        				datasource->PrevValue = (FLOAT)obj.Syntax.LngUns;
						break;
					default:	     
						ERROR(MODULE, NEURO_INVDATASRC);
						return FALSE;
					}
				}
				else
				{
					ERROR(MODULE, NEURO_NOSUCHDATASRC);
					return FALSE;
				}
			}
		}
	}

    return TRUE;
}

 
BOOLEAN NeuroCChangeTimer(NeuroData* data, ULONG msecs)
{
	if (TimerChange(data->Timer, msecs) == 0)
		return FALSE;
	return TRUE;
}


INT NeuroThresholds(InOutData *data)
{
    switch (data->ThresholdCheck)
    {
    case NO_THRESHOLD:
        return 0;
    case LESS_THAN:
    case GREATER_THAN:
    case EQUAL:
    case NOT_EQUAL:
        return 1;
    case IN_RANGE:
    case OUT_RANGE:
        return 2;
    }

    return 0;
}


NeuroData* NewNeuroData(VOID)
{
	return (NeuroData*)MALLOC(sizeof(NeuroData));
}


VOID DelNeuroData(NeuroData* data)
{
	FREE(data);
}


InOutData* NewInOutData(LONG nrinouts)
{
InOutData* new;
LONG i;

	if ((new = MALLOC(nrinouts*sizeof(InOutData))) != NULL)
		for (i = 0; i < nrinouts; i++)
			InOutDataInit(&new[i]);
	return new;
}

		    
InOutData* ReNewInOutData(InOutData* data, LONG nrinouts, LONG prvnrinouts)
{
InOutData* new;
LONG i;

	if ((new = REALLOC(data, nrinouts*sizeof(InOutData))) != NULL)
		for (i = prvnrinouts; i < nrinouts; i++)
			InOutDataInit(&new[i]);
	return new;
}

				       
VOID InOutDataInit(InOutData* data)
{
WORD i;

	data->Id[0] = 0;
	data->Id[1] = 0;
	data->IdLen = 2;
	data->PrevValue = 0;
	data->TheValue = 0;
	data->MaxValue = 1000;
	data->MinValue = 0;
	data->AverageMethod = SIMPLE_DIFF;
	data->AverageSteps = 1;
	for (i = 0; i < MAXNRSTEPS; i++)
		data->Value[i] = 0;
	data->Trap = FALSE;
	strcpy(data->TrapComm, "trap");
	data->TrapCommLen = strlen("trap");
	data->ThresholdCheck = NO_THRESHOLD;
	for (i = 0; i < MAXNRTHRESHOLDVALUES; i++)
		data->ThresholdValue[i] = 0;
}


VOID DelInOutData(InOutData* data)
{
	FREE(data);
}


InOutBatch* NewInOutBatch(LONG nrinouts)
{
InOutBatch* new;
LONG i;

	if ((new = MALLOC(nrinouts*sizeof(InOutBatch))) != NULL)
		for (i = 0; i < nrinouts; i++)
			InOutBatchInit(&new[i]);
	return new;
}

		    
InOutBatch* ReNewInOutBatch(InOutBatch* data, LONG nrinouts, LONG prvnrinouts)
{
InOutBatch* new;
LONG i;

	if ((new = REALLOC(data, nrinouts*sizeof(InOutBatch))) != NULL)
		for (i = prvnrinouts; i < nrinouts; i++)
			InOutBatchInit(&new[i]);
	return new;
}

				       
VOID InOutBatchInit(InOutBatch* data)
{
	data->TheValue = 0;
}


VOID DelInOutBatch(InOutBatch* data)
{
	FREE(data);
}


FLOAT* NewOutputValues(LONG nrouts)
{
FLOAT *p;
LONG i;

	if ((p = MALLOC(nrouts*sizeof(FLOAT))) == NULL)
        return NULL;
    for (i = 0; i < nrouts; i++)
        p[i] = 0;
    return p;
}


FLOAT* ReNewOutputValues(FLOAT* values, LONG nrouts)
{
FLOAT *p;
LONG i;

	if ((p = REALLOC(values, nrouts*sizeof(FLOAT))) == NULL)
        return NULL;
    for (i = 0; i < nrouts; i++)
        p[i] = 0;
    return p;
}


VOID DelOutputValues(FLOAT* values)
{
	FREE(values);
}