C++での通信処理におけるデータの取りこぼし

Question

###前提・実現したいこと
カメラから取得したRGBデータをネットワーク経由で他のPCへ送信するプログラムを作成しています．
現在通信にはWinsock2でUDP通信を使用しています．

###発生している問題
取得した画素情報を逐次送信した場合，recvfrom()でデータを取りこぼす．

###該当のソースコード

// Send.cpp
#include "SocketCom.h"
#define HEIGHT 480
#define WIDTH 640
static char pixelData[3][HEIGHT][WIDTH]; //送信したいピクセルデータ

int main(void){
	InitSendSocketCommunication("127.0.0.1", 11111);

   	----- データ格納及びシーケンス番号を付与する処理 -----

	// 送信処理
	for (int i = 0; i < HEIGHT ; i++){
		SendCharToPartner(pixelData[0][i], sizeof(pixelData[0][i]));
		SendCharToPartner(pixelData[1][i], sizeof(pixelData[1][i]));
		SendCharToPartner(pixelData[2][i], sizeof(pixelData[2][i]));
	}

	return 0;
}

// Receive.cpp
#include "SocketCom.h"
#define HEIGHT 480
#define WIDTH 640
static char pixelData[3][HEIGHT][WIDTH]; //受信したピクセルデータ

int main(void){
	InitReceiveSocketCommunication("127.0.0.1", 11111);

   	----- データ格納及びシーケンス番号を付与する処理 -----

	// 受信処理
	for (int i = 0; i < HEIGHT ; i++){
		ReceiveDataAsChar(pixelData[0][i], ARRAY_SIZE(pixelData[0][i]));
		ReceiveDataAsChar(pixelData[1][i], ARRAY_SIZE(pixelData[1][i]));
		ReceiveDataAsChar(pixelData[2][i], ARRAY_SIZE(pixelData[2][i]));

    	----- シーケンス番号を元に対応する配列に格納する処理 -----
	}

	return 0;
}

// SecketCom.h
#define UDP_MAX 65507	// UDP通信にて一度に送信することができる最大サイズ
#define ARRAY_SIZE(arr) ( sizeof(arr) / sizeof(arr[0]) )	// 配列の要素数を返すスクリプト

#include <string>
using std::string;

// Description:
//  送信する変数型一覧．
typedef enum Datatype{
	TYPE_INT,
	TYPE_DOUBLE,
} Datatype;

// IPアドレスとポート番号で初期化する
extern bool InitSendSocketCommunication(string	IPAdress,int portnumPartner);
extern bool InitReceiveSocketCommunication( string IPAdress,int	portnumPartner);
extern bool FinalSocketCommunication();
extern bool SendStringToPartner(string sendData);
extern bool SendValueToPartner(void *sendData,int arraySize,Datatype datatype);
extern bool ReceiveDataAsChar(	char *receivedata,int dataSize);
extern bool ReceiveDataAsValue(	void *data,int dataSize,Datatype datatype);

// SocketCom.cpp
//=============================================================================
// include / using / define
//=============================================================================

// ソケット通信
#include <winsock2.h>
// string
#include "SocketCommunication.h"
using std::to_string;
// 文字列出力
#include <iostream>
using std::cout;
using std::endl;

#define STR(var) #var
#define SEPARATOR "/"


//=============================================================================
// variable
//=============================================================================

static SOCKET g_sockSend, g_sockReceive;		// 送受信の通信プロトコル設定
static struct sockaddr_in g_addrSend, g_addrReceive;	// 送受信のアドレス，ポート設定
static bool isInitialized = false;
static int g_socketError = 0;
static bool g_isBind = false;
static int sockaddr_in_size;


//=============================================================================
// Static Function
//=============================================================================

// WinSockのバージョンを指定
static bool InitWSAData(){
	WSADATA wsaData;
	int error;

	error = WSAStartup(MAKEWORD(2, 0), &wsaData);
	if (error != 0){
		cout << "Winsock WSAStartup Error (SocketCommunication.cpp > InitWSAData())" << endl;
		cout << STR(error) << endl;

		return false;
	}
	isInitialized = true;
	return true;
}

//=============================================================================
// Initialize / Finalize Functions
//=============================================================================

// 送信の初期化
bool InitSendSocketCommunication(string IPAdress, int portnumPartner){

	if (!isInitialized)
		if (!InitWSAData())
			return false;

	// 送信のプロトコルを決める
	g_sockSend = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	g_addrSend.sin_family = AF_INET;
	g_addrSend.sin_port = htons(portnumPartner);
	g_addrSend.sin_addr.S_un.S_addr = inet_addr(IPAdress.c_str());

	return true;
}

// 受信の初期化
bool InitReceiveSocketCommunication(string IPAdress, int portnumRecv){
	if (!isInitialized)
		InitWSAData();

	// 送信のプロトコルを決める
	g_sockReceive = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	g_addrReceive.sin_family = AF_INET;
	g_addrReceive.sin_port = htons(portnumRecv);
	g_addrReceive.sin_addr.S_un.S_addr = INADDR_ANY;
	sockaddr_in_size = sizeof(struct sockaddr_in);

	if (!g_isBind){
		g_socketError = bind(g_sockReceive, (struct sockaddr *)&g_addrReceive, sizeof(g_addrReceive));
		if (g_socketError != 0){
			cout << "Port bind failture! (SocketCommunication.cpp > ReceiveDataAsChar() > bind())" << endl;
			return false;
		}
		g_isBind = true;
	}
	char val;
	int len;
	
	return true;
}

// ソケット通信の終了
bool FinalSocketCommunication(void){
	closesocket(g_sockSend);
	WSACleanup();

	return true;
}


//=============================================================================
// Send / Receive Functions
//=============================================================================

// 文字列の送信
bool SendStringToPartner(string sendData){
	// UDPの限界を超えていないかチェック
	if (sendData.size() > UDP_MAX){
		cout << "Data size is too large! (SocketCommunication.cpp > SendStringToPartner() > string sendData)" << endl;
		return false;
	}

	g_socketError = sendto(g_sockSend, sendData.c_str(), sendData.size(), 0, (struct sockaddr *)&g_addrSend, sizeof(g_addrSend));
	if (g_socketError == -1){
		cout << "Data send failture! (SocketCommunication.cpp > SendStringToPartner() > sendto())" << endl;
		return false;
	}

	return true;
}

// 数値の送信（文字列へ変換して送る）
bool SendValueToPartner(void *sendData, int arraySize, Datatype datatype){
	string buffer;
	int *bufInt;
	double *bufDouble;
	
	switch (datatype){
		case TYPE_INT:
			bufInt = (int*)sendData;

			for (int j = 0; j < arraySize; j++){
				buffer += to_string(*(bufInt + j));
				buffer += SEPARATOR;
			}
			break;
		case TYPE_DOUBLE:
			bufDouble = (double*)sendData;

			for (int j = 0; j < arraySize; j++){
				buffer += to_string(*(bufDouble + j));
				buffer += SEPARATOR;
			}
			break;
	}

	if( !SendStringToPartner(buffer) )
		return false;

	return true;
}

// charデータの受信
bool ReceiveDataAsChar(char *data, int dataSize){
	// UDPの限界を超えていないかチェック
	if (dataSize > UDP_MAX){
		cout << "Data size is too large! (SocketCommunication.cpp > ReceiveDataAsChar() > int dataSize)" << endl;
		return false;
	}	

	memset(data, 0, dataSize);

		g_socketError = recvfrom(g_sockReceive, data, 1284, 0, (struct sockaddr *)&g_addrReceive, &sockaddr_in_size);
	if (g_socketError < 0){
		cout << "Data receive failture! (SocketCommunication.cpp > ReceiveDataAsChar() > recv())" << endl;
		cout << "ERROR_CODE：" << WSAGetLastError() << endl;
		return false;
	}

	return true;
}

// 数値データの受信
bool ReceiveDataAsValue(void *data, int dataSize, Datatype datatype){
	char buffer[UDP_MAX];
	static char *p;	//正直謎ポインタ（for strtok_s()）

	// とりあえずchar型として受け取る
	if (!ReceiveDataAsChar(buffer, sizeof(buffer)))
		return false;

	// doubleとかはcharとデータサイズが違うから，数値データ一つ毎にSEPARATORをはさんで送る
	switch (datatype){
	case TYPE_INT:
		*((int*)data) = atof( strtok_s( buffer, SEPARATOR, &p ) );
		for (int i = 1; i < dataSize; i++)
			*((int*)data + i) = atof(strtok_s(NULL, SEPARATOR, &p));
		break;
	case TYPE_DOUBLE:
		*((double*)data) = atof( strtok_s( buffer, SEPARATOR, &p ) );
		for (int i = 1; i < dataSize; i++)
			*((double*)data + i) = atof(strtok_s(NULL, SEPARATOR, &p));
		break;
	}

	return true;
}

###試したこと
送信のforループの中に無意味な処理（"for (int h = 0; h < 1000000; h++)"）を追加して送信の間隔を空けた場合，取りこぼすことなく受信することができた．しかし速度を重視してUDPを採用したので，可能であれば無意味な処理を使用せず実行したいと考えている．

###補足情報(言語/FW/ツール等のバージョンなど)
IDE
Visual Studio 2013 Express for Windows Desktop

Answer 1

速度を重視する代わりに取りこぼしが起きるのがUDPです。UDPを使う以上、取りこぼしを防ぐのは無理だと思います。もし取りこぼしに対する検証処理を書くなら、最初からTCPを使うほうが良いと思います。

Comments

[Unity-chan]

回答ありがとうございます。
UDPを用いているので多少の取りこぼしがあるのは許容できます．しかしWireSharkでパケットを確認すると，受信自体はできているように見えるにも関わらずrecvfrom()を実行した場合に良くても10%程のデータしか受け取ることが出来ませんでした．
今まで取りこぼしの主な原因は通信経路上のパケットロスと思っていたのですが，こういったロスも多いのでしょうか…．その場合だとTCPにした方がいいかもしれません．

[masaya_ohashi]

んー…そこまで詳しい調査をしたことはないのでどこに原因があるかは不明です。
UDPは下手な鉄砲数撃ちゃ当たるで、TCPは必中スナイパーライフルのようなもの、とだけ認識して使っていたので、詳しくはわかりません。UDPは多少間が抜けても構わないもの、TCPは絶対抜け落ちてはならないものに使うので、画像等の1つのバイナリデータを送信するならTCPを使うのが無難かと思います。

Answer 2

他回答へのコメントより：

UDPを用いているので多少の取りこぼしがあるのは許容できます．しかしWireSharkでパケットを確認すると，受信自体はできているように見えるにも関わらずrecvfrom()を実行した場合に良くても10%程のデータしか受け取ることが出来ませんでした．

質問者さんが言及している通り、UDPはあらゆるレイヤでデータグラム欠損が起きうる通信プロトコルです。実ネットワーク上でのパケット・ロス発生以外にも、NIC内部で破損検知したデータグラムを破棄したり、ネットワークスタック内部の送受信バッファ不足によりデータグラムを破棄することもあります。

SO_SNDBUFやSO_RCVBUFにより送受信バッファサイズを大きくすれば、UDPデータグラムの取りこぼしが多少は減る可能性があります。

送信のforループの中に無意味な処理（"for (int h = 0; h < 1000000; h++)"）を追加して送信の間隔を空けた場合

UDP送信処理という観点からは、上記のような微妙なタイミング制御には意味があります。データグラム欠損を極力避けるには、UDP送信側はなるべく一定間隔でのデータ送信を行うよう制御し（バースト的な送出処理は避ける）、UDP受信側は可能な限り最速でネットワークスタックからデータを取り出す（recvfromとその後の解析処理を分離するなど）必要があります。

しかし速度を重視してUDPを採用したので，可能であれば無意味な処理を使用せず実行したいと考えている．

（気持ちは分かりますが）UDP通信路全体でみると全くの逆効果です。送信側だけの都合で最速処理すると、既に説明したようなデータグラム欠損があちこちで生じてしまいます。

Comments

[Unity-chan]

返答が遅くなって申し訳ありません！
以下のプログラムを追加してバッファを大きくしたところ正常に動作することを確認できました。ありがとうございます。
int recvBuffer
setsockopt(g_sockReceive, SOL_SOCKET, SO_RCVBUF, (char *)&recvBuffer, OptLen);