public SOM(AppSettings appSettings )
{
_appSettings = appSettings;
_netState = NET_STATE.init;
_trainingPhase = TRAINING_PHASE.phase_1;
_currentIteration = 1;
_totalMapError = 0.0f;
_isNeuronSelected = false;
_selectedNeuronCoords = new Point( 0, 0 );
_isTrained = false;
_timeConstant_P1 = (float)_appSettings.numIterations_P1 / (float)Math.Log( _appSettings.mapRadius );
_learningRate_P1 = _appSettings.startLearningRate_P1;
_learningRate_P2 = _appSettings.startLearningRate_P2;
// Allocate memory.
_competitionLayer = new Neuron[ SOMConstants.NUM_NODES_DOWN, SOMConstants.NUM_NODES_ACROSS ];
for ( int i = 0; i < SOMConstants.NUM_NODES_DOWN; ++i ) {
for ( int j = 0; j < SOMConstants.NUM_NODES_ACROSS; ++j ) {
_competitionLayer[ i,j ] = new Neuron( i, j );
}
}
_errorMap = new float[ SOMConstants.NUM_NODES_DOWN, SOMConstants.NUM_NODES_ACROSS, 3 ];
Run();
}
public void close()
{
state_ = NET_STATE.DISCONNECTED;
socket.Close();
// ContentsProcee_ = null;
}
public void disConnect()
{
state_ = NET_STATE.DISCONNECT;
PK_C_REQ_EXIT packet = new PK_C_REQ_EXIT();
this.sendPacket(packet);
}
public void close()
{
state_ = NET_STATE.DISCONNECTED;
//heartBeatWorker_.Abort();
stream_.Close();
stream_.Flush();
client_.Close();
packetProcee_ = null;
}
public void close()
{
state_ = NET_STATE.DISCONNECTED;
stream_.Close();
stream_.Flush();
client_.Close();
ContentsProcee_ = null;
}
public SocketConnectClient()
{
mOutputBuffer = new DoubleBuffer <byte[]>();
mReceiveBuffer = new DoubleBuffer <SocketPacket>();
mReceiveThread = new MyThread("SocketReceive");
mSendThread = new MyThread("SocketSend");
mRecvBuff = new byte[8 * 1024];
mInputBuffer = new StreamBuffer(1024 * 1024);
mConnectStateLock = new ThreadLock();
mSocketLock = new ThreadLock();
mReceivePacketHistory = new Queue <string>();
mHeartBeatTimer = new MyTimer();
mNetState = NET_STATE.NONE;
}
protected void socketException(SocketException e)
{
// 本地网络异常
NET_STATE state = NET_STATE.NET_CLOSE;
if (e.SocketErrorCode == SocketError.NetworkUnreachable)
{
state = NET_STATE.NET_CLOSE;
}
else if (e.SocketErrorCode == SocketError.ConnectionRefused)
{
state = NET_STATE.SERVER_CLOSE;
}
notifyNetState(state, e.SocketErrorCode);
}
protected void notifyNetState(NET_STATE state, SocketError errorCode = SocketError.Success)
{
mConnectStateLock.waitForUnlock();
mNetState = state;
if (isUnconnected())
{
clearSocket();
}
CMD(out CommandSocketConnectClientState cmd, false, true);
if (cmd != null)
{
cmd.mErrorCode = errorCode;
pushDelayCommand(cmd, this);
}
mConnectStateLock.unlock();
}
// 接收Socket消息
protected void receiveSocket(ref bool run)
{
if (mServerSocket != null && mServerSocket.Connected && mConnectState == CONNECT_STATE.CS_CONNECTED)
{
try
{
(mRemoteEndPoint as IPEndPoint).Address = IPAddress.Any;
(mRemoteEndPoint as IPEndPoint).Port = 0;
int nRecv = mServerSocket.ReceiveFrom(mRecvBuff, ref mRemoteEndPoint);
if (nRecv <= 0)
{
// 由于需要保证状态正确,所以此处需要立即调用设置状态
notifyDisconnectServer();
// 服务器异常
setNetState(NET_STATE.NS_SERVER_CLOSE);
return;
}
mInputBuffer.addData(mRecvBuff, nRecv);
// 解析接收到的数据
while (true)
{
PARSE_RESULT parseResult = parsePacket();
// 数据解析成功,继续解析
if (parseResult != PARSE_RESULT.PR_SUCCESS)
{
break;
}
}
}
catch (SocketException e)
{
// 由于需要保证状态正确,所以此处需要立即调用设置状态
notifyDisconnectServer();
// 本地网络异常
NET_STATE state = NET_STATE.NS_NET_CLOSE;
if (e.ErrorCode == 10051)
{
state = NET_STATE.NS_NET_CLOSE;
}
else if (e.ErrorCode == 10061)
{
state = NET_STATE.NS_SERVER_CLOSE;
}
setNetState(state);
}
}
}
public Network()
{
// 패킷 큐 생성
readPacketQueue = new Queue <Packetinterface>();
writePacketQueue = new Queue <Packetinterface>();
PacketQueue = readPacketQueue;
//서버의 상태 초기화
state_ = NET_STATE.START;
// lock 오브젝트 생성
//소켓생성
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//// arg 할당
//sendArgs = new SocketAsyncEventArgs();
//receiveArgs = new SocketAsyncEventArgs();
//// args 에 대한 함수 등록
//sendArgs.Completed += new EventHandler<SocketAsyncEventArgs>(sendArgs_func);
//receiveArgs.Completed += new EventHandler<SocketAsyncEventArgs>(receiveArgs_func);
// TODO : arg 가 가지고 있을 object 할당
// args 버퍼 설정
// sendArgs.SetBuffer(0, 1024 * 10);
// receiveArgs.SetBuffer(0, 1024 * 10);
// 수신 바이트를 관리할 버퍼
packetBytes = new Byte[1024 * 10];
// 수신바이트의 총바이트수와 CurrentOffset 초기화
totalBytes = 0;
//
}
public bool Connect(string ip, uint port)
{
client_ = new TcpClient();
try
{
client_.Connect(ip, Convert.ToInt32(port));
}
catch
{
Debug.Log("Connect Failed");
return(false);
}
state_ = NET_STATE.CONNECTED;
stream_ = client_.GetStream();
return(true);
}
public bool connect(string ip, uint port)
{
client_ = new TcpClient();
try
{
client_.Connect(ip, Convert.ToInt32(port));
}
catch
{
Debug.Log("서버 연결 실패");
return(false);
}
state_ = NET_STATE.CONNECTED;
stream_ = client_.GetStream();
heartBeatWorker_ = new Thread(new ThreadStart(heartBeat));
heartBeatWorker_.Start();
return(true);
}
public bool Connect(string ip, int port)
{
Debug.Log("Reqest Connect ip : " + ip + "port :" + port.ToString());
var endPoint = new IPEndPoint(IPAddress.Parse(ip), port);
try
{
socket.Connect(endPoint);
}
catch
{
Debug.Log("Connect Failed");
return(false);
}
state_ = NET_STATE.CONNECTED;
return(true);
}
public override void resetProperty()
{
base.resetProperty();
mReceiveBuffer.clear();
mOutputBuffer.clear();
mReceivePacketHistory.Clear();
mInputBuffer.clear();
// mConnectStateLock,mSocketLock不需要重置
//mConnectStateLock;
//mSocketLock;
mIPAddress = null;
mReceiveThread.stop();
mSendThread.stop();
mHeartBeatTimer.stop();
mSocket = null;
memset(mRecvBuff, (byte)0);
mHeartBeatTimes = 0;
mPort = 0;
mNetState = NET_STATE.NONE;
}
public bool connect(string ip, uint port)
{
client_ = new TcpClient();
try {
client_.Connect(ip, Convert.ToInt32(port));
} catch {
MessageBox.Show("서버 연결 실패", "error", MessageBoxButtons.OK);
return(false);
}
state_ = NET_STATE.CONNECTED;
stream_ = client_.GetStream();
readWorker_ = new Thread(new ThreadStart(receive));
readWorker_.Start();
heartBeatWorker_ = new Thread(new ThreadStart(heartBeat));
heartBeatWorker_.Start();
return(true);
}
// 发送Socket消息
protected void sendSocket(ref bool run)
{
if (mServerSocket != null && mServerSocket.Connected && mConnectState == CONNECT_STATE.CS_CONNECTED)
{
// 获取输出数据的读缓冲区
var readList = mOutputBuffer.getReadList();
try
{
foreach (var item in readList)
{
int sendCount = 0;
while (sendCount < item.Length)
{
sendCount += mServerSocket.Send(item, sendCount, item.Length - sendCount, SocketFlags.None);
}
}
}
catch (SocketException e)
{
// 由于需要保证状态正确,所以此处需要立即调用设置状态
notifyDisconnectServer();
// 服务器异常
NET_STATE state = NET_STATE.NS_NET_CLOSE;
if (e.ErrorCode == 10051)
{
state = NET_STATE.NS_NET_CLOSE;
}
else if (e.ErrorCode == 10061)
{
state = NET_STATE.NS_SERVER_CLOSE;
}
setNetState(state);
}
// 回收缓冲区的内存
foreach (var item in readList)
{
mCollectedBytes.addToBuffer(item);
}
readList.Clear();
}
}
protected void connectCallback(IAsyncResult ar)
{
try
{
mServerSocket.EndConnect(ar);
}
catch (SocketException e)
{
// 由于需要保证状态正确,所以此处需要立即调用设置状态
notifyDisconnectServer();
NET_STATE state = NET_STATE.NS_NET_CLOSE;
if (e.ErrorCode == 10051)
{
state = NET_STATE.NS_NET_CLOSE;
}
else if (e.ErrorCode == 10061)
{
state = NET_STATE.NS_SERVER_CLOSE;
}
setNetState(state);
return;
}
setNetState(NET_STATE.NS_CONNECTED);
}
public virtual void init(IPAddress ip, int port, float heartBeatTimeOut)
{
mIP = ip;
mPort = port;
mHeartBeatTimer.init(-1.0f, heartBeatTimeOut, false);
try
{
// 创建socket
mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
mServerSocket.Connect(mIP, mPort);
}
catch (SocketException e)
{
logInfo("init socket exception : " + e.Message, LOG_LEVEL.LL_FORCE);
mServerSocket.Close();
mServerSocket = null;
// 服务器连接失败也要开启接收和发送线程
mSendThread.start(sendSocket);
mReceiveThread.start(receiveSocket);
NET_STATE state = NET_STATE.NS_NET_CLOSE;
if (e.ErrorCode == 10051)
{
state = NET_STATE.NS_NET_CLOSE;
}
else if (e.ErrorCode == 10061)
{
state = NET_STATE.NS_SERVER_CLOSE;
}
setNetState(state);
return;
}
notifyConnectServer();
mConnectState = CONNECT_STATE.CS_CONNECTED;
mSendThread.start(sendSocket);
mReceiveThread.start(receiveSocket);
}
public void StopTraining()
{
_netState = NET_STATE.neutral;
}
protected abstract void setNetState(NET_STATE state);
public void StartTraining()
{
_netState = NET_STATE.training;
Run();
}
protected override void setNetState(NET_STATE state)
{
;
}
public Network()
{
stream_ = null;
state_ = NET_STATE.START;
}
public override void init()
{
base.init();
mNetState = NET_STATE.NS_SERVER_CLOSE;
}
public void Run()
{
switch (_netState)
{
case NET_STATE.neutral:
{
break;
}
case NET_STATE.init:
{
_isTrained = false;
Init();
_netState = NET_STATE.neutral;
break;
}
case NET_STATE.training:
{
if (Epoch())
_netState = NET_STATE.finished;
break;
}
case NET_STATE.finished:
{
_isTrained = true;
_totalMapError = CalculateErrorMap();
Mapping();
_netState = NET_STATE.neutral;
break;
}
} // End switch.
}
