研究ぶーろぐ

//

#include
#include
#include


class Txc5 : public cSimpleModule
{
//変更部分　受け取ったものを一回
private:
cMessage *event; //自分になげる
cMessage *tictocMsg;//相手になげる

//コンストラクタとデストラクタ宣言
public:
Txc5();
virtual ~Txc5();

protected:
virtual void initialize();
virtual void handleMessage(cMessage *msg);
};

Define_Module(Txc5);

//コンストラクタ内容
Txc5::Txc5()
{
event = tictocMsg = NULL; //定義として最初をNULLとする
}
//デスクトラクタ
Txc5::~Txc5()
{
//eventは特殊なdelete方法をとる
cancelAndDelete(event);
delete tictocMsg;
}

void Txc5::initialize()
{
// event messageを作成
event = new cMessage("event");

// tictocは全くまだ通信していません
tictocMsg = NULL;

if (strcmp("tic", name()) == 0)
{
// 最初５s待つ
ev << "最初 send to t=5.0s\n";
//cMessage作成
tictocMsg = new cMessage("tictocMsg");
//eventに5s待ってもらう
scheduleAt(5.0, event);
}
}

void Txc5::handleMessage(cMessage *msg)
{
if (msg==event)
{
// event messageが到着したので、待ち時間終了するため、outにして、ポインタを切る
ev << "メッセージを返送して待ちの期間終わり\n";
send(tictocMsg, "out");
tictocMsg = NULL; //
}
else
{
//cMessageが到着したので1秒まつ
ev << "Message arrived, starting to wait 1 sec...\n";
tictocMsg = msg;
scheduleAt(simTime()+1.0, event);
}
}

今まではmessageの投げ合いだったが、
５は、一回ポケットに入れるイメージ

・投げるmessageは2種類ある
自分　event　　　　⇒scheduleAt(何秒後,投げるメッセージ)
相手　cMessage

どちらもhandl

#include
#include


class Txc2 : public cSimpleModule
{
protected:
//以下の再定義された仮想の機能はアルゴリズムを保持します

//privateと同じだが、subclassみたらpublicにみえる
virtual void initialize();
virtual void handleMessage(cMessage *msg);
};

//モジュールのクラスは、OMNeT++に登録される必要があります。
Define Module(Txc2);

void Txc2::initialize()
{
//最初のメッセージをticとする
if (strcmp("tic", name()) == 0)
{
// 'ev'オブジェクトはC++における'cout'のように働いています。
//１→２変更部分
ev << "Sending initial message\n"; //ここまで cMessage *msg = new cMessage("tictocMsg"); send(msg, "out"); } } void Txc2::handleMessage(cMessage *msg) { // msg->name() is name of the msg object, here it will be "tictocMsg".変更部分↓
ev << "Received ぼーどめっせーじ `" <<>name() << "', sending it ぼーどあうと again\n";
send(msg, "out");
}

simple Txc2
gates :
in: in;
out: out;
endsimple

module Tictoc2
submodules:
//2の変更部分
tic: Txc2;
display: "i=round/process,cyan";,
toc: Txc2;
display: "i=block/process,pink"
//ここまで
connections:
tic.out --> delay 100ms --> toc.in;
tic.in <-- delay 100ms <-- toc.out;
endmodule

network tictoc2:Tictoc2
endnetwork

//モジュールの構成やモジュール間の接続に関する定義をNED言語でしている
//OMNet++のシミュレーションモデルは複数モジュールがお互いに接続しあうことで構成
//tictocは２つのモジュールで１つのシミュレーションを構築
//シンプルモジュールの宣言
simple Txc1
//gateの宣言　gateはin/outの手のこと
gates:
in: in; //inという変数にinを設定
out: out;
endsimple

//
/Txc1の2つの例(ticとtoc)が両方の道を接続
//チックとtocはメッセージをお互いに渡す

//複合モジュールの宣言
module Tictoc1
//submodukleは複合の中にあるmodule
//今はsimplemoduleのticとtocである
submodules:
tic: Txc1; //考え方としてTxc1クラスのtic tocというオブジェクトを作成
toc: Txc1; //つまり、in/outという手をもつことになる
connections:
//手を繋いでやる
//ticのoutからtocのinへ渡すとき、100msの遅延を生じる
tic.out --> delay 100ms --> toc.in;
tic.in <-- delay 100ms <-- toc.out;
endmodule

//network オブジェクト名：複合モジュール名
//こうすると、そのかかれたモジュールがシミュレーションモデルとして扱われる
network tictoc1 : Tictoc1
endnetwork

#include
#include //omnetをみている

class Txc1:public cSimpleModule
{
//以下の再定義された仮想の機能はアルゴリズムを保持します
protected: //privateと同じだが、subclassみたらpublicにみえる
virtual void initialize();
virtual void handlemessage(cMessage *msg);
}

//モジュールのクラスは、OMNeT++に登録される必要があります。
Define Module(Txc1);

void txc1::initialize()
{
//初期化、シミュレーションの始めに呼ばれます。tic>toc>tic>tocの過程を独力で進むために、
//モジュールの1つは、最初のメッセージを送る必要があります。
//これが'チック'であるとさせてください。
if (strcmp("tic",name()) == 0)
{
//赤丸（メッセージ）を作り出す
cMessage *msg = new cMessage("tictocMsg");
//最初のメッセージをゲート“out"に作成して、送ってください。
//"tictocMsg"はメッセージオブジェクトの名前になる任意のストリングです。
send(msg,"out");
}
}
void Txc1::handleMessage(cMessage *msg)
{
//メッセージがモジュールに到着するときはいつも、handleMessageメソッドは呼ばれます。
//ここで、私たちはゲート'out'を通してただもう片方のモジュールにそれを送ります。
//'チック'と'toc'の両方が同じようにするので、メッセージは2つの間で弾むでしょう。
send(msg,"out");
}

TicToc Tutorial for OMNeT++

tictoc１．
２つのノードはtic tocとよぶ


tictoc２．
NEDに表示ストリングを追加によって可能（表示ストリングのi=タグはアイコンを指定する）
tic：シアン
toc：黄色


tictoc3．
カウンタに、10回交換の後にメッセージを削除というモジュールを追加

class human　//人間を定義するぞ
{
private:　　//privateにするのは名前を相手から読み取るようなもの。普通privateにする。
string name;　//stringという型（文字列）のnameを宣言
public:
human(string s){
name = s;　//このコンストラクタは文字列を外から受け取りそれをsとする
}
void hanasu(){ //「動作：話す」　人を話させる関数
cout<<"ちわっす。私は"<<<"だにょ。"<



■　クラスとオブジェクト
人：クラス　（データ：名　や　動作：話す　などが定義されている）
mtmr：オブジェクト（実体）　←　人クラス

■　コンストラクタ
int main　が神としたら、　コンストラクタは人を生めと言ってるようなもの。
最初にかならず読み込まれる。
humanというクラスにあるhumanという名前の関数
クラス名と同名の関数は、特別なものでコンストラクタとよばれる

//「引数の値（sで表される）を、メンバ変数nameに代入する」
human(string s){
name = s;
}

これは以下に書き換えＯＫ
//「name(s)」が、「変数nameを作るときにsの値を格納する」
Neko(string s) : name(s){}

コンストラクタの定義の「Rocket::Rocket(int x)」の「int x」は、「引数の値をxにコピーする」

■　humanクラスの松村オブジェクト作成
human mtmr("松村");

クラス名 変数(引数);
この変数で表わされるオブジェクトが生成され、そのときにコンストラクタが実行される
（「string name;」や「int tosi;」と同じイメージである）

■　humanであるmtmrに、hanasu関数を実行
mymr.hanasu();

変数 . 関数(あれば引数);
↑変数（=「オブジェクト」を表わす）に対して、関数が実行されるということです。

■　オブジェクトのデータを変えないメンバ関数
後ろにconstをつける
「この関数は実行してもデータを変えない」

void hanau() const{
cout<<"私は"<<<"だ。"<インライン関数
「使われる場所」全部にその内容が書き込まれる関数
「クラス定義の中にメンバ関数を書くと、コンパイラに、その関数をインライン化するよう要求することになる」
処理が長い関数はインライン化しないのが普通である

//インライン化しないプログラム
class Neko
{
string name;

//クラス定義の下にあるのが、クラス定義の外にあるコンストラクタとnakuの定義
public:
Neko(string s); //コンストラクタがあるよ
void naku() const; //nakuという関数があるよ
};

//「NekoというクラスのNekoという関数（コンストラクタ）」
Neko::Neko(string s) : name(s){}　

//「Nekoというクラスのnakuという関数」
void Neko::naku() const{
cout<<"にゃあ。俺様は"<<<"だ。"<

■　関数の前の void
「何も報告しないで終わる」という程度の意味

// Class1b.cpp
#include 

#define ELEM(array)  (sizeof (array) / sizeof *(array))

class SStudent
{
public:
   char szName[16];
   int  nJapanese;
   int  nMath;
   int  nEnglish;

   void Disp();
};

void SStudent::Disp()
{
   cout << "名前 : "   << szName    << endl
        << "　国語 : " << nJapanese << " 点, "
           "数学 : "   << nMath     << " 点, "
           "英語 : "   << nEnglish  << " 点" << endl;
}

int main()
{
   SStudent students[] = {
       { "赤井孝",   73, 98, 86, },
       { "笠井大介", 64, 45, 40, },
       { "吉田叶",   76, 78, 69, },
   };
   int      i;

   for(i = 0; i < ELEM(students); i++)
       students[i].Disp();

   return 0;
}
----------------------------------------------
■　クラスとオブジェクトの書き方

SStudent mtmr = {"松村",0,0,1};
mtmr.Disp();

SStudent students[] = {
　　　　　　　　　　　　{"松村",0.0.1}
　　　　　　　　　　　　{"赤井",0,2,5}
}
student[i].Disp();

-----------------------

• 構造体の宣言の書式は struct <名前>{ <変数宣言群> }; 。
• 構造体を使えば、関連のある変数をひとまとめに扱える。
• 構造体の宣言は、型の宣言である。
• 構造体の各要素はメンバと呼ぶ。
• メモリ上にある変数を実体（インスタンス）と、
  構造体変数のことをオブジェクトと呼ぶ。
• メンバを使うときは、<オブジェクト>.<メンバ> とする。

メモリの勉強に時間をくわれまくってます。

さすがにイライラしてきたお(｀ω´#)

■　ファイル：ディスク上にあるデータを整理、管理したもの
■　ファイルはディスク上に存在（メモリ上ではない）
■　内容を利用するには、メモリに読み込んだり、メモリから書き出したりする必要がある。
　　 なので読み出したデータを入れるための場所を用意してやる必要がある＝バッファと呼ぶ。

■　fwrite(&nLength, 4, 1, pFile);
引数について＝

　&nLength：書き込みたいデータの置いてあるアドレス
　　　　　　　　書き込みたいデータは nLength に入っているから、先ずこのアドレスを渡す

　4　　　　　 ： 書き込むデータの１要素のサイズ

　1 　　　　　： 書き込むデータの要素数
　　　　　　　　 配列を書き込むときに、配列の１つ１つのサイズと、そして配列の要素数を指定する
　　　　　　　　 しかし、無茶苦茶でもOK。
　　　　　　　　面倒なら、一方を１にして、もう一方にデータ全体の長さを指定したのでもOK

　pFile　　　： 書き込むファイル

ポインタメモ

#include 

int main()
{
char a;
char* p;　//char 型の変数のアドレスを入れられる

//変数のアドレスは変数の前に & を付ければ得られる

p = &a; //アドレスを入れれるpにaのアドレスを入れている
cout << " p = " << (unsigned int) p << style="color:darkcyan;">"&a = " << (unsigned int)&a << style="color:blue;">return 0;
}


--------------------------------------------------------------

　char* p;
　　p =　アドレス
　 *p =　データ

--------------------------------------------------------------

■　const char p = 251;
　//p = 251　を書き換えることはできない

■　const char *p;
　//参照先が定数
　 p は定数にならない
　　*p = あ; だときめられたら、　 *p =　い;　と書き直せない


p を定数にしたい場合
■char *const p = &a;
　//* の後ろに const を入れます
ポインタ p が定数

--------------------------------------------------------------
おまけｖ
【名前のつけかた】

数は n（ number の略）
文字列は sz（ string (zero-terminated) の略）
ポインタは p（ pointer の略）
変数には接頭辞を付ける
マクロは全て大文字にする

「A P2PSIP Demonstrator Powered by Oversim」
を読みました

著者
Ingmar Baumgart, Bernhard Heep, Stephan Krause

出典
Peer-to-Peer Computing, 2007. P2P 2007. Seventh IEEE International Conference, 2007

※churn = ノードが断続的にネットワークへの離脱参加を繰り返すような状況のこと

4．
我々のでもストレーションにより、OverSimフレームワークのいくつかの重要な特徴を閉めそう。
まず、OverSimプロトコルの実装が現実のネットワークでどのように再利用できるかと、OverSimにより供給されるKBRおよびDHTのサービスが実際のアプリケーションにどのように使われるかを示す。
さらに我々はどのようにOverSimがわずかな物理的デバイスを用いてデモストレーションをより現実的にするために、ひとつのホストにおいて大量のオーバーレイnodesを開放させるために用いられるかを示す。
最後に我々は、OverSimのGUIの能力のchurn？のもとにChord overlatトポロジの視覚化を示す予定である。

A．アーキテクチャ
デモストレーションアーキテクチャは802.11gインターフェイスを伴ういくつかのNokia770インターネットタブレットとLinuxラップトップとEthernetに繋がれたレガシーSIP Phoneと古いTOPS Phoneからなる。最後に高度なパフォーマンスのサーバーがあり、それは大量の負荷的Overlay Nodeに匹敵する。
アーキテクチャの全体像は図１に示されている。
nokia770とラップトップの各々が、SIP soft phoneアプリケーションであるmini SIP、すなわちSIP ProxyとOversim instanceに基づくOpen sirを動かしている。OverSimはcommon API(3)に基づくXML-RPCインターフェイスを通じてSIP ProxyにKBRとDHTサービスを供給するために使われている。
OverSim instanceは802.11gインターフェイス上で互いにコミュニケーションを図り、論理的Chord linkを形成する。
レガシーSIPとPOTS PhoneもまたP2PSIPネットワークに接続するために、Serverに作られたSIP Proxyを用いる。
Overlayトポロジをより現実的なものにするために、更なるOverlay nodeが高度なServerによってはしらされるもうひとつのOversum instanceによって競いあう。このOversim instanceはまた競い合うネットワークトポロジとOverlay通信を視覚化するGUIを持つ。
B .P2PSIPのシナリオ
P2PSIPのシナリオにおいて我々はどのようにSIPを特定するものが表示されChordOverlayNetworkで見つけられるかについて示す。
まず、userはNOKIA770のひとつの上で任意のSIPを示すものを選ぶ。するとその装置はOverlaynetworkに接続し、たとえば、もうひとつのNOKIA770や競いあっているハイパフォーマンスなサーバー上のNodeといったほかのOverlay nodeのひとつに保存する。
もしも、同じSIPの特定するものが既に他のuserによって使用されている場合は、その使用は拒否される。
次の段階において、新しく登録された特定する人は他のNOKIA770か伝統的SIP Phoneから呼び出される。これはDHT内に保存されているSIP identifier（特定されたもの）の自動照合を含む。自動照合のプロセス全体はserver上のGUIに視覚化される。

C．Churn下のOverlay protocol視覚化
2つ目のシナリオにおいて我々はOverSimのシミュレーション能力をデモストし、安定したChurnのもとでのOverlayプロトコルの様相を視覚化する（図２）
Overlay nodeは設定変更可能な時間間隔を用いてネットワークを周期的に出入りする。永久的に変化するOverlayトポロジはメインのシミュレーションウィンドウで視覚化される。Overlay Nodeに取って代わるものと、それ以前に使われていたNodeのようなChordは色つきの矢印で示されている。それはトポロジ調整と修繕が行いやすいからである。
あらゆるNodeがテストアプリケーションを行っており、それが周期的にランダムNode nodeiesに対しproveメッセージを送っているが、それはOverlayのパフォーマンスを継続的に計測するためである。
たとえば、その目的値に対し首尾よくメッセージを送る割合といった配達の割合は全体的なシミュレーションが行われている間特別のウィンドウにプロットされる。配達の割合におけるOverlay nodeの参加・脱退の効果はNodeがOverlayについたり離れたりする感覚を帰ることによって強調されている。