C/C++

[C++]mutexいろいろ

出水洸太郎 — Fri, 16 Dec 2011 00:38:00 GMT

これは16日目の Boost Advent Calendar 2011 の参加記事です。

マルチスレッドのプログラムを作る場合、切っても切れないのがmutexです。
同じリソースにアクセスする時はmutexのロックを使って、
複数のスレッドが同時にアクセスするのを制限しないといけません。

例えば、std::cout で文字列を出力するのはスレッドセーフではないので、
複数のスレッドから同時に呼び出すと、出力が混じり合うことがあります。
なので、こんな感じでmutexを使って排他にしなければなりません。

static boost::mutex dispmutex;
void Display(const std::string &fname, const std::string &str){
  boost::mutex::scoped_lock lk(dispmutex);
  std::cout << fname << ":" << str << std::endl;
}

scoped_lockを使うことで、そのスコープの間だけロックを掛ける、ということができます。
途中でreturnやbreakなどでスコープを抜けた場合もロックを外してくれるので、
mutexのlock/unlockを使うよりは、scoped_lockを使うといいでしょう。

さて、預金管理システムを作ってみました。
残高照会、預け入れ、引き出しができます。
預け入れに上限チェックしていませんが、
私の預金が32bitの上限が超えそうなときまでには考えます。

なお、どの関数も1秒ほどの処理時間がかかるものとします。

class Yokin{
  boost::mutex access;
  int money;
public:
  Human(int money):money(money){}
  void Zandaka(){
    boost::scoped_lock lk(access);
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  } 

  void Azukeire(int h){
    boost::scoped_lock lk(access);
    money += h;
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  } 

  void Hikidashi(int h){
    boost::scoped_lock lk(access);
    if (h <= money){
      money -= h;
    }
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  }
};

これは無駄な部分があるので、高速化してみます。
Zandaka()は値を読み込んで表示しているだけですので、
Azukeire()やHikidashi()が動いていない間なら並列で走らせても問題なさそうです。

そこで、boost::mutexより細かくロックレベルを変えられるのがboost::shared_mutexです。
それを使って先ほどのクラスを書き換えてみます。

class Yokin{
  boost::shared_mutex access;
  int money;
public:
  Human(int money):money(money){}
  void Zandaka(){
    boost::shared_lock<boost::shared_mutex> read(access);
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  } 

  void Azukeire(int h){
    boost::unique_lock<boost::shared_mutex> write(access);
    money += h;
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  } 

  void Hikidashi(int h){
    boost::unique_lock<boost::shared_mutex> write(access);
    if (h <= money){
      money -= h;
    }
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  }
};

値を読むだけならshared_lockを使い並列に動くようにして、
値を書き換える場合はunique_lockを使って排他にします。
これで、残高照会中に別スレッドの残高照会が動くようになって高速化しました。

しかし、もうちょっと高速化の余地があります。
Hikidashi()を見てみると、お金が足りない時はデータを書き換えません。
つまり、お金があるときのみ、unique_lockをすればよいです。
それを踏まえて書き換えてみます。

  void Hikidashi(int h){
    boost::shared_lock<boost::shared_mutex> shared(access);
    if (h <= money){
　    boost::unique_lock<boost::shared_mutex> unique(access);
      money -= h;
    }
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  }

更に高速化！…するどころか、返ってきません。
どうやら、デッドロックしているようです。

お金を減らすとき、unique_lockを通過するには
shared_lockを含め、すべてのロックが外れていることが条件です。
しかし、自分自身がshared_lockをかけています。

  void Hikidashi(int h){
    boost::shared_lock<boost::shared_mutex> shared(access);
    if (h <= money){
      shared.unlock();
　    boost::unique_lock<boost::shared_mutex> unique(access);
      money -= h;
    }
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  }

スコープの途中でも、unlock関数を使うことで、ロックを外すことができます。
もう使わない！となったらすぐに開放したほうがいいでしょう。

こうして、デッドロックはなくなりましたが…残高がマイナス？？
どうやら、if文を抜けた後、別のスレッドで値を書き換えられたようです。

ロックは一度確保したら使い終わるまで一瞬でも開放してはいけません。
今回はshared_lockのアンロック→unique_lockの間に一瞬ロックが外れていて
その間に別のスレッドが値を書き換えているわけです。

こういう、書き換えるかもしれないときに使うロックがupgrade_lockです。

  void Hikidashi(int h){
    boost::upgrade_lock<boost::shared_mutex> upgrade(access);
    if (h <= money){
      boost::upgrade_to_unique_lock<boost::shared_mutex> write(upgrade);
      money -= h;
    }
    Display(__FUNCTION__, boost::lexical_cast<std::string>(money));
  }

upgrade_lockはshared_lockとは干渉しないので
引き出し額が足りないときはZandaka()とは並列して動きます。
引き出し額が足りているときは、upgrade_to_unique_lockを使ってunique_lockに切りかえ、
その時にshared_lockが解除されるまで待ちます。

まとめると以下のようになります。

shared_lock	unique_lockがあるときにブロック
upgrade_lock	upgrade_lock, unique_lockがあるときにブロック unique_lockに変更可能
unique_lock	shared_lock, upgade_lock, unique_lockがあるときにブロック

アクセスが集中するリソースではこれらのロックを適切に使っていきたいです。

以上、Boost Advent Calender 2011 16日目、shared_mutexの紹介でした。
明日の17日目は @egtra さんです。
よろしくお願いします。

[C++]あちこちを転々と shared_ptr

出水洸太郎 — Thu, 28 Oct 2010 11:20:00 GMT

前回の続きです。
[C++]楽々TCPサーバ

前回紹介したソースなのですが、その中でtcp_connectionについて解説します。

class tcp_connection
  : public boost::enable_shared_from_this<tcp_connection>{

  void start_receive(){
    socket_.async_receive(
      boost::asio::buffer(recv_buffer_), 
      boost::bind(&tcp_connection::handle_receive, shared_from_this(),
      boost::asio::placeholders::error, _2));
  }
};

前回作成したtcp_connectionをもうちょっと見てみましょう。

よく見ると、boost::enable_shared_from_this というクラスから派生しています。
そして、async_recieveの引数をよく見ると、shared_from_thisという関数が見えます。

class udp_server{

  void start_receive(){
    socket_.async_receive_from(
      boost::asio::buffer(recv_buffer_), remote_endpoint_,
      boost::bind(&udp_server::handle_receive, this,
        boost::asio::placeholders::error, _2));
  }
};

同じ部分をUDPサーバで見てみましょう。
shared_from_this()の部分はただのthisですね。
UDPとTCPの差…ではありません、実体の差です。

実体…つまりどこで変数が確保されているか、です。
udp_serverクラスはmain関数内で確保されています。
では、tcp_connectionクラスはどこでしょうか。

前回にちょこっと書いたとおり、tcp_connection::create()関数が呼ばれているところを探せばいいのです。
tcp_server::start_accept()にありますね。

classs tcp_connection{
  typedef boost::shared_ptr<tcp_connection> pointer;
};

class tcp_server{

  void start_accept(){
    tcp_connection::pointer new_connection =
      tcp_connection::create(acceptor_.io_service());

    acceptor_.async_accept(new_connection->socket(),
      boost::bind(&tcp_server::handle_accept, this, new_connection,
      boost::asio::placeholders::error));
  }
};

tcp_connection::pointerってのはtcp_connectionをshared_ptrで包んだものです。
shared_ptrなので、この関数を抜けたときに開放され…ると困りますね。
handle_acceptに引数として渡されているので、handle_accept関数が終わるまでは生きています。

  void handle_accept(tcp_connection::pointer new_connection,
    const boost::system::error_code& error){
    if (!error){
      new_connection->start();
      start_accept();
    }
  }

ここでは、もうnew_connectionを持ち続けてはいません。
この関数を抜けたところで、tcp_connectionは開放されそうです。

いや、おかしいです。
逆にいつまで生きていて欲しいか、を考えると、TCPの通信が切断されるまで生きてないと困ります。

そこで、最初のtcp_connection::start_acceptに戻ります。
thisの代わりにshared_from_thisを使っています。
つまり、自分自身のshared_ptrを待ち受けイベントに忍び込ますことで、
自分自身が開放されるのを防いでいるわけです。

そして、だれも次の待ち受けイベントを登録しなくなった次点でtcp_connectionは開放されます。

なお、shared_from_this(this)と書く代わりにboost::shared_ptr(this)ではだめなのか。
shared_ptrはすでに作られているshared_ptrを探してくるわけではありません。
つまり、ポインタを管理するクラスが2つ出来てしまい、二重管理になってしまいます。

ここで出てきたshared_from_thisを提供するクラスが、boost::enable_shared_from_thisです。
内部的に自分自身のweak_ptrを持っています。
で、必要に応じてweak_ptrをshared_ptrに変換して、渡してあげるわけです。

shared_ptrでなくweak_ptrの理由は、shared_ptrだと自分自身がもっているものを捨てないと
自分自身が解放されないという、一種の循環参照になっているためです。

ということで、shared_ptrをうまく使う事で管理するクラスを作ってないのに
必要なくなったときに解放されるというtcp_connectionクラスを作っています。
もう、なんというか無茶苦茶ですね。

[C++]楽々TCPサーバ

出水洸太郎 — Tue, 26 Oct 2010 09:34:00 GMT

[C++]楽々UDPサーバ

ということで、今回はTCPサーバです。

#include <iostream>
#include <string>
#include <boost/array.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>

using boost::asio::ip::tcp;

class tcp_connection
  : public boost::enable_shared_from_this<tcp_connection>{
  tcp::socket socket_;
  boost::array<char, 4096> recv_buffer_;

private:
  tcp_connection(boost::asio::io_service& io_service)
    : socket_(io_service){}

  void handle_write(boost::shared_ptr<std::vector<char> > /* sendbuf */, size_t /* len */ ){}

  void handle_receive(const boost::system::error_code& error, size_t len)
  {
    if (!error || error == boost::asio::error::message_size){
      /* メッセージ表示 */
      std::string message(recv_buffer_.data(), len);
      std::cout << message << std::endl;

      /* エコー */
      boost::shared_ptr<std::vector<char> > sendbuf( 
        new std::vector<char>(recv_buffer_.begin(), recv_buffer_.begin() + len) );

      boost::asio::async_write(socket_, boost::asio::buffer(*sendbuf),
        boost::bind(&tcp_connection::handle_write, shared_from_this(), sendbuf, len));

      start_receive();
    }
  }

  void start_receive(){
    socket_.async_receive(
      boost::asio::buffer(recv_buffer_), 
      boost::bind(&tcp_connection::handle_receive, shared_from_this(),
      boost::asio::placeholders::error, _2));
  }
public:
  typedef boost::shared_ptr<tcp_connection> pointer;

  static pointer create(boost::asio::io_service& io_service){
    return pointer(new tcp_connection(io_service));
  }

  tcp::socket& socket(){
    return socket_;
  }

  void start(){
    std::cout << socket_.remote_endpoint().address() << ":" << socket_.remote_endpoint().port() << std::endl ;

    start_receive();
  }
};

class tcp_server{
  tcp::acceptor acceptor_;
  void start_accept(){
    tcp_connection::pointer new_connection =
      tcp_connection::create(acceptor_.io_service());

    acceptor_.async_accept(new_connection->socket(),
      boost::bind(&tcp_server::handle_accept, this, new_connection,
      boost::asio::placeholders::error));
  }

  void handle_accept(tcp_connection::pointer new_connection,
    const boost::system::error_code& error){
    if (!error){
      new_connection->start();
      start_accept();
    }
  }
public:
  tcp_server(boost::asio::io_service& io_service, int port)
    : acceptor_(io_service, tcp::endpoint(tcp::v4(), port)){
      start_accept();
  }
};

int main(){
  try{
    boost::asio::io_service io_service;
    tcp_server server1(io_service, 10000);
//  udp_server server2(io_service, 10000);
    io_service.run();
  }
  catch (std::exception& e){
    std::cerr << e.what() << std::endl;
  }

  return 0;
}

TCPのサーバを作った人ならわかるでしょうが、TCPには2つの段階があります。

まず、相手からの接続を受け付けるためのリスナーを作成します。
その後、誰かが接続してくればそこで接続を確立し、再度リスナーは待ち受けに戻ります。

まずはその部分から見てみましょう。

  tcp_server(boost::asio::io_service& io_service, int port)
    : acceptor_(io_service, tcp::endpoint(tcp::v4(), port)){
      start_accept();
  }

コンストラクタです。
UDPとほぼ同じと言っていいでしょう。

  void start_accept(){
    tcp_connection::pointer new_connection =
      tcp_connection::create(acceptor_.io_service());

    acceptor_.async_accept(new_connection->socket(),
      boost::bind(&tcp_server::handle_accept, this, new_connection,
      boost::asio::placeholders::error));
  }

ここで、リスナーのイベントを登録します。
リスナーの待ち受けにソケットクラスが必要なので、
この時点で接続した時のクラスを作っておきます。

  void handle_accept(tcp_connection::pointer new_connection,
    const boost::system::error_code& error){
    if (!error){
      new_connection->start();
      start_accept();
    }
  }

接続時のハンドルクラスです。
new_connectionに接続した時の処理を行ない、再度リスナーに待ち受けイベントを登録します。

次は接続したときの相手をするtcp_connectionクラスです。

コンストラクタ、createは省略します。ま、見ればわかりますね。
なお、コンストラクタがprivateにあるのはnewで他のクラスから生成できないようにするためです。
newの代わりにcreate関数を使ってね、って事ですね。

  void start(){
    std::cout << socket_.remote_endpoint().address() << ":" << socket_.remote_endpoint().port() << std::endl ;

    start_receive();
  }

接続してきたら、誰か接続してきたのかを表示して、パケットが飛んできた時の待ち受けを行ないます。
socket_.remote_endpoint()で誰が接続したのかを取り出すことが出来ます。
なお、socket_.local_endpoint()は自分自身のIPやポートが入っていますので注意。

start_receive関数も省略。ただイベント登録しているだけですね。

  void handle_receive(const boost::system::error_code& error, size_t len)
  {
    if (!error || error == boost::asio::error::message_size){
      /* メッセージ表示 */
      std::string message(recv_buffer_.data(), len);
      std::cout << message << std::endl;

      /* エコー */
      boost::shared_ptr<std::vector<char> > sendbuf( 
        new std::vector<char>(recv_buffer_.begin(), recv_buffer_.begin() + len) );

      boost::asio::async_write(socket_, boost::asio::buffer(*sendbuf),
        boost::bind(&tcp_connection::handle_write, shared_from_this(), sendbuf, len));

      start_receive();
    }
  }

UDPサーバと同じく、相手から送られたメッセージを画面に表示して、
その後送られたパケットをそのまま投げ返しています。

なお、async_writeというのを使っています。
UDPと同じく、send関数を使ってもいいのですが、非同期送信を使ってみました。
送信が終了したらhandle_write関数が呼び出されます。

send関数を使う場合は送信用バッファをローカルに確保しても良いのですが、
非同期送信なのでローカルに確保するとまずいことになります。
また、メンバー変数として確保してもやはり先にhandle_recieveが先に2回呼ばれてしまうと、
最初のバッファが2回目のデータで上書きされてしまいます。
そこで、shared_ptrを使い、毎回送信用バッファを作成しているわけです。

handle_writeは何もしていません。
特に送信後に何かを行うイベントがないのでこうなっています。
ではこの関数は要らないの？と思いますが、引数に送信バッファを持っています。
つまり、このshared_ptrがこの関数が終わるまで生きているわけです。
この関数は送信後に呼ばれるため、送信用バッファを送信後に破棄するためにこの関数が必要になります。

ということで、TCPサーバも100行程度で作れました。
いやぁ、boost便利ですね！

[C++]あれがarrayか

出水洸太郎 — Sun, 24 Oct 2010 08:31:00 GMT

boost::arrayの紹介しているページで、こんな記述が。
letsboost::array

boost::array<int, 4> ar2 = {{0, 100, 200, 300}};
// 普通の配列似の初期化

中括弧が２つ？？　なにこれ？？
で、調べた結果です。

boost::arrayって大雑把にカットすると、こういう事なんです。

struct array{
  int elems[4];
};

で、思い出して欲しいのがこんな書き方。

struct Point{
  int x, y;
};

Point pos = {10, 20};

C言語時代では良くある初期化ですね。

これを踏まえた上で、下の書き方を見てみると…。
ほら、普通の書き方だ！！

int elems[4] = {0, 100, 200, 300};

struct array ary = { {0, 100, 200, 300} };

なお、コンストラクタを持つとこういう初期化はできなくなります。
出来るのはPOD型ってやつですね。
ということで、boost::arrayはPOD型で作ってあります。

なお、別に中括弧2つ重ねなくても不思議な力によってエラーもでないし問題なく動きます。
initializer_listの関係ですかね？

[C++]楽々UDPサーバ

出水洸太郎 — Sat, 23 Oct 2010 09:13:00 GMT

最近boostを真面目に使い始めたので、その辺を書いてみます。
今回はudpサーバの作り方です。

TCPじゃなくてUDP？って感じですが、UDPの方がシンプルなのでまずはこちらを理解しましょう。

#include <ctime>
#include <iostream>
#include <string>
#include <boost/array.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>

using boost::asio::ip::udp;

class udp_server
{
  udp::socket socket_;
  udp::endpoint remote_endpoint_;
  boost::array<char, 512> recv_buffer_;

public:
  udp_server(boost::asio::io_service& io_service, int port)
    : socket_(io_service, udp::endpoint(udp::v4(), port)){
    start_receive();
  }

private:
  void start_receive(){
    socket_.async_receive_from(
      boost::asio::buffer(recv_buffer_), remote_endpoint_,
      boost::bind(&udp_server::handle_receive, this,
        boost::asio::placeholders::error, _2));
  }

  void handle_receive(const boost::system::error_code& error, size_t len){
    if (!error || error == boost::asio::error::message_size){
      std::string message(recv_buffer_.data(), len);

      std::cout << remote_endpoint_.address() << ":" << remote_endpoint_.port() << std::endl ;
      std::cout << message << std::endl;

      socket_.send_to(boost::asio::buffer(recv_buffer_, len), remote_endpoint_);

      start_receive();
    }
  }
};

int main(){
  try{
    boost::asio::io_service io_service;
    udp_server userver(io_service, 10000);
    io_service.run();
  }
  catch (std::exception& e)  {
    std::cerr << e.what() << std::endl;
  }

  return 0;
}

udp_serverクラスを見てみましょう。まずは変数部分。

  udp::socket socket_;
  udp::endpoint remote_endpoint_;
  boost::array<char, 512> recv_buffer_;

変数は3つ、ソケット、エンドポイント、それと受信用バッファですね。
エンドポイントってのは、IPやらポートやらを格納するクラスです。
今回はパケットの送信元を格納するために使います。

バッファにboost::arrayを使っていますが、従来のchar [512]の書式だと、
どれだけの長さのバッファが確保されているのか、ってのを取得する方法がないんですね。
(sizeofを使った取得方法が一応ありますけど…)
foreachやイテレータにも対応しているので、使えるときにはこちらを使いましょう。

  udp_server(boost::asio::io_service& io_service, int port)
    : socket_(io_service, udp::endpoint(udp::v4(), port)){
    start_receive();
  }

コンストラクタでは、ソケットにio_serviceとUDPサーバに必要な物を渡します。
そして、start_receiveって関数を呼んでいます。

  void start_receive(){
    socket_.async_receive_from(
      boost::asio::buffer(recv_buffer_), remote_endpoint_,
      boost::bind(&udp_server::handle_receive, this,
        boost::asio::placeholders::error, _2));
  }

start_recieveってのはパケットを受信した時のイベント登録をする関数です。
async_で始まるのは非同期イベントの登録を意味します。
つまり、UDPのパケットを受け取ったら、handle_receive関数を呼び出すイベントを登録しています。

boost::bindのおかげでメンバー関数をコールバックできる当たりが素敵。

  void handle_receive(const boost::system::error_code& error, size_t len){
    if (!error || error == boost::asio::error::message_size){
      std::string message(recv_buffer_.data(), len);

      std::cout << remote_endpoint_.address() << ":" << remote_endpoint_.port() << std::endl ;
      std::cout << message << std::endl;

      socket_.send_to(boost::asio::buffer(recv_buffer_, len), remote_endpoint_);

      start_receive();
    }
  }

その呼び出されるhandle_receiveの中身。

handle_receive関数はエラーでも呼び出されるので、エラーでない時だけ通常処理をします。
受信したデータをIP、ポートと一緒に画面に表示し、送信元に投げ返します。
その後、再度イベントを登録します。

一度イベントが呼び出された時点でイベントの登録が無効になるので、
もう一度登録しなおさないと駄目なんですね。

ちなみに、message_sizeってのはバッファがあふれた時のエラーです。
このエラーは無視します。

int main(){
  boost::asio::io_service io_service;
  udp_server userver(io_service, 10000);
  io_service.run();
  return 0;
}

最後はmain関数。例外部分は省きました。
io_serviceってのがイベントの面倒をみるクラスです。
今回はudpserverクラスしか登録していませんが、同時にtcpserverクラスも登録して
両方の面倒を見てもらう、という使い方もできます。

イベントをゴニョゴニョ！っと登録したらio_service.run()で待ち受け開始！
後は延々とUDPサーバが動き続けます。

ということで、わずか50行程度でUDPサーバができちゃうわけですよ、すごい！
しかも、WindowsだのLinuxだのというOSを意識しないってのもいいですね。

[C++]右辺値参照の限界点

出水洸太郎 — Sat, 21 Aug 2010 11:14:00 GMT

右辺値参照を調べてわかった事。

右辺値参照はオブジェクトのコピーをするときに
条件さえ整えば高速におこなう事を目的に作られた構文です。

右辺値参照が役に立つのは、関数内でポインタの形で情報を持っているものに限られます。
ですから、直接値を持つ形になっているクラスには何の貢献もしません。
具体的には、以下のような例です。

/* 役に立つ例 */
class MyString{
  char *string;
} 

/* 役に立たない例 */
class Matrix44{
  float m[4][4];
}

下の例の行列なんかは演算子オーバーロードで書ければすっきりするのですが、
実際にはそういうわけにはいきません。

/* こんな関数は速くならない */
Matrix44 operator +(const Matrix44 &in1, const Matrix44 &in2); 

/* 現実的な解 */
void Add(Matrix &out, const Matrix44 &in1, const Matrix44 &in2);

右辺値参照を最初に聞いた時、こんな事ができる！と期待してました。

/* 私がやりたかった事 */
auto operator +(const Matrix44 &in1, const Matrix44 &in2) -> Matrix44 &out{
  for(int x = 0; x < 4; x++){
    for(int y = 0; y < 4; y++){
      out[x][y] = in1[x][y] + in2[x][y];
    }
  }
}

返り値を受け取る変数って、関数を呼び出した時点で
破壊されているものとみなしてもいいと思うんですよ。(例外やlongjmpは無視)
そして、その返り値を受け取る変数の参照が欲しい！！

ということで名前付き返り値なんてものがあってもいいんじゃないかな～。
VBなんかが返り値は関数名と同名の変数に入れるタイプですね。

と思ってたら、どうやらReleaseモードでの最適化で似たような事をしてくれるらしいです。
(以下の記事のコメント欄参照)
http://blogs.wankuma.com/episteme/archive/2010/08/06/192085.aspx

…最適化してくれるのなら右辺値参照はいらない子なんじゃと思う今日この頃です。
コピー以外に使い道はあるんでしょうかね？

[C++]コルーチンへの挑戦

出水洸太郎 — Wed, 28 Apr 2010 22:59:00 GMT

C++でコルーチンを作ってみるテストです。

さて、下のソースを見てください。
このFooという関数はまさにコルーチンです。

#include "coroutine.h"

class Test:public Coroutine{
　int i;

public:
　bool Foo(){
　　CoroutineBegin();
　　for (i = 1; i <= 20; i++){
　　　printf("%d ", i);
　　　yield;
　　　if ((i % 3) == 0){
　　　　printf("fizz ");
　　　　yield;
　　　}
　　　if ((i % 5) == 0){
　　　　printf("buzz ");
　　　　yield;
　　　}
　　}
　　CoroutineEnd();
　　return true;
　}

};

int _tmain(int argc, _TCHAR* argv[])
{
　Test test;
　for (;;){
　　bool finish = test.Foo();
　　if (finish) break;
　　printf("---\n");
　}

　return 0;
}

実行結果はこんな感じになります。

1 ---
2 ---
3 ---
fizz ---
4 ---
5 ---
buzz ---
6 ---
fizz ---
7 ---
8 ---
9 ---
(以下省略)

コルーチンのyieldが呼ばれる度にメインルーチンに戻ってハイフンと改行が出力されています。
いいですね、コルーチン！

こんな素敵なコルーチンが使えるヘッダファイルが今ならもう一個ついて1980円！
じゃなくて、こちらからダウンロードできます。

#あくまで使用は自己責任で

[C++]ランダム大地に立つ

出水洸太郎 — Tue, 19 Jan 2010 22:35:00 GMT

標準のrand関数は余り使わない方がいい、というのは知っているでしょうか。
これは線形合同法に起因する問題で、乱数といいつつも、結構規則正しいという特徴があります。

それを改良した乱数と言うとメルセンヌ・ツイスタが有名ですが、これもちょっとした問題があります。
それは、メモリの消費がかなり多い！

周期が2^19937 - 1 ということは、19937ビットのデータが必要なのです。
その大きさは約2.5KBですが、いくら高品質とはいえ、ちょっと量が多いですね。

それに、2^19937 - 1って数は6000桁以上！
宇宙の果てまで数えられる数の周期が必要な場面はそんなにないでしょう。

そこで、今回紹介するお手頃な乱数が、xorshift。
ソースは以下の通り。

unsigned long xor128(){ 
  static unsigned long x=123456789,y=362436069,z=521288629,w=88675123; 
  unsigned long t; 
  t=(x^(x<<11));x=y;y=z;z=w; return( w=(w^(w>>19))^(t^(t>>8)) ); 
}

これだけのソースですが、2^128 - 1という周期をもつ乱数で、たった16バイトしか消費しません。
staticで確保しているx, y, z, wの4つの値を保存しておくだけで、前回の乱数の続きから生成できるため、
シリアライズ化するのも簡単というとてもお手軽かつ便利な乱数です。

なお、乱数の種(seed)ですが、x, y, z, wのすべてが0でなければどんな数でもいいです。
これは、128ビットの数値と見なすと、周期が2^128 - 1ということで、0以外の数値であれば、
循環する数列のどれかの要素になる、というわけです。

そういえば、メルセンヌ・ツイスタを改良したSFMTというものもあるみたいですね。
乱数は奥が深いです。

[数学][C]直線交差点

出水洸太郎 — Wed, 14 Oct 2009 20:44:00 GMT

[数学]捻じれて縺れてこんがらかるの続き、計算編です。

まず、お互いの直線をベクトルと見なし、その外積を求めます。
この外積は何を意味するかというと、前回の平行な面における法線となっています。

この法線がわかれば、平行な面どうしの距離を計算する事が出ケイます。
それぞれの面から適当な点を１つづつ取り、bの面からaの面へ向かうベクトルを作ります。

この時、cと法線ベクトルの内積を求めれば、お互いの面の距離がわかります。
内積は、あるベクトル成分をどれだけ持っているか、という計算にも使えるわけです。

この辺のからくりがわからなくても、cと法線ベクトルが直角ならば、
aの面とbの面がぴったりくっついている、というのがわかればいいです。

ということで、こんな感じのソースになります。

int LineHitCheck(const Vec3 &a1, const Vec3 &a2, const  Vec3 &b1, const Vec3 &b2){
  Vec3 va = a1 - a2;
  Vec3 vb = b1 - b2;
  Vec3 nv = outer(va, vb);
  Vec3 vc = a1 - b1;

  if (nv.x == 0 && nv.y == 0 && nv.z == 0){
    // 平行or同一の場合
    Vec3 nv2 = outer(va, vc);
    if (nv2.x == 0 && nv2.y == 0 && nv2.z == 0){
      return 同一;
    }else{
      return 平行;
    }
  }else{
    // 交差orねじれの場合
    if (inner(vc, nv) == 0){
      return 交差;
    }else{
      return ねじれ;
    }
  }
}

平行だったときの場合は飛ばしましたが、直線Aと直線Bが同一ということは、
直線B上にあるすべての点が直線A上にあるということです。
ですから、直線Aの一点と直線Bの一点を結ぶベクトルは、常に直線Aベクトルと0度or180度であり、
外積を求めると必ず零ベクトルになります。

ねじれの直線の距離は、法線ベクトルを正規化してcベクトルとの内積を求めると出ます。
カプセルの当たり判定で求める事があるかもしれません。

[数学][C]内積と外積を軽く分析

出水洸太郎 — Wed, 14 Oct 2009 09:55:00 GMT

[数学]捻じれて縺れてこんがらかるの続きです。

今回は軽くおさらいです。
ベクトルを使うに当たり、三次元空間の内積、外積を解説します。

・内積
別名、スカラー積ともよばれ、ベクトルaとベクトルbの内積は一次元の数値となります。
要は、ベクトルじゃないよ、ってことです。

なお、内積が0になるときは、掛け合わせたベクトルが直交するときです。
これは二次元における内積と同じです。

なお、計算式は以下のようになります。
ｘ、ｙ、ｚそれぞれを掛け合わせてたします。

struct Vec3{
  int x, y, z;
};

int inner(const Vec3 &a, const Vec3 &b){
  return a.x * b.x + a.y * b.y + a.z * b.z;
}

・外積
別名、ベクトル積で、ベクトルaとベクトルbの内積はベクトルとなります。
この外積で出てくるベクトルはベクトルa、ベクトルbの両方に直交します。

前を表すベクトルと、上を表すベクトルから右を表すベクトルを作り出せます。
ここで、前と上を表すベクトルは必ずしも直行しなくてよいことが重要です。

なお、外積の結果が零ベクトルになることがありますが、
これは掛け合わせたベクトルが同一方向か逆方向を向いているときです。

先ほどの例だと、前を表すベクトルが真上を向いてしまうと、
北極点における東方向という感じで、右方向というのが決まらなくなってしまいます。
こういう場合に零ベクトルとなるわけです。

外積の計算式は以下の通りです。
x→y→z→x というローテーションを意識して、別々を掛けて引くというという形になります。

Vec3 outer(const Vec3 &a, const Vec3 &b){
  Vec3 c;
  c.x = a.y * b.z - a.z * b.y;
  c.y = a.z * b.x - a.x * b.z;
  c.z = a.x * b.y - a.y * b.x;
  return c;
}