デザイン系の学生がプログラミングするブログ(仮)

Reaction Diffusion 3D

2011-06-10T03:08:00.010+09:00

反応拡散系のシュミレーションをoFで書いてみた。３次元２成分のGray Scottモデルを使用。

参考は、Nervous Systemのこのコードと、このページ。

最初、FitzHugh-Nagumoモデルに書きなおしていじってたけど、よさげなパラメータが見つからずgdgdになったので放置。結局、単純に元ネタをcppに翻訳した感じになった。

RD_GrayScott3D_Mesh.zip （使用しているアドオンはofxMarchingCubes、ofxSTL、ofx3DUtils、ofxVectorMath。）

GUIはきまぐれで自作。実はMarchingCubesも自作してたけど、後から見つけたアドオンのほうが出来がよかったのでお蔵入りになった。残念。

貝のやつ

2011-05-07T02:28:00.000+09:00

HIGASHISMのひとを見てたら自分もやってみたくなったので、やってみた。

円錐からの整形は早々に諦めてwebでカンニングしてたところいい感じにまとまったサイトを発見したので参考にしつつcinderで実装してみた。

上記のサイトにのってるアルゴリズムは基本的な殻の生成に加え、瘤を発生させることができ、画像のようなトゲの生えた貝も描画できる。
以下がソース（SimpleGUIが必要。）

TheMuseumOfAllShells.zip

法線計算が力技でかなりひどく、また瘤の挙動が仕様か実装ミスか時々変なのが気になる。時間できたら、手を加えよう。

あと、gitにある最新のcinderで該当箇所のコメントアウト（TheMuseumOfAllShellsAppApp.cppの263行目くらい）を外してビルドするとメッシュを.obj形式で保存できるようになる。なかなか便利。

openframeworks上でのアンチエイリアスのかけ方

2011-04-18T21:09:00.029+09:00

tipsを二つメモ。openframeworksでアンチエイリアスをかける方法と、ワイヤーフレームを描画する方法について

まずは、アンチエイリアスをかける方法について。oF（v0062）はデフォルトだとジャギーがかなり目立つ。なんとなく以前からアンチエイリアスの実装方法を探していたけど、最近oFのフォーラムで方法がのっているのを発見したので試してみた。

//main.cppファイルにて
#include "ofMain.h"
#include "testApp.h"
#include "ofAppGlutWindow.h"

//========================================================================
int main( ){
 ofAppGlutWindow window;
 //アンチエイリアスを有効にする
 window.setGlutDisplayString("rgb alpha double samples>=4 depth");
 ofSetupOpenGL(&window, 500,500, OF_WINDOW);
 ofRunApp( new testApp());
}

ofSetupOpenGLの前にwindow.setGlutDisplayString("rgb alpha double samples>=4 depth");と一行追加するだけ。すごい簡単だった。

つづいて、ワイヤフレームを描画する方法。processingのようにポリゴンをワイヤーフレームで表示したい時、ポリゴンの描画方法をglPolygonModeで切り替えれる。
例えば、ワイヤーフレームのみ表示する場合は

//ワイヤーフレームを描画
 ofSetColor(50, 50, 50);
 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);//ポリゴンの表と裏をワイヤーフレームで描画する
 glutSolidCube(5);
 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);//変更した設定をもとに戻す。ポリゴンの表と裏を塗りつぶす。
 ofSetColor(255, 255, 255);

ワイヤーフレームと面を両方表示する場合は、面とワイヤーフレームの二回に分けて描画すればいいが、そのままだとワイヤーフレームが面にめり込んだ状態で表示される可能性があるため、glPolygonOffsetでオフセットを付けてやる必要がある。

//面を描画
 ofxLightsOn();
 glEnable(GL_POLYGON_OFFSET_FILL); //オフセット値を有効化
  glPolygonOffset(1, 1);      //オフセット値を決定
 glutSolidCube(5);
 glDisable(GL_POLYGON_OFFSET_FILL); //変更した設定をもとに戻す。オフセット値を無効化。
 ofxLightsOff();
 
 //ワイヤーフレームを描画
 ofSetColor(50, 50, 50);
 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);//ポリゴンの表と裏をワイヤーフレームで描画する
 glutSolidCube(5);
 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);//変更した設定をもとに戻す。ポリゴンの表と裏を塗りつぶす。
 ofSetColor(255, 255, 255);

こんな感じ。

以上をひとまとめにしたソースはこちら。（ofx3dutilsとofxVectorMathがアドオンに必要。）

断面図の出力

2011-04-04T01:20:00.007+09:00

3Dモデルの断面図を計算するコードをスケッチしてみた。

forked from: Voronoi 3D - wonderfl build flash online

前回のsplitMeshをやっつけで書きなおしただけなのでコードは汚め。

3Dモデルのアウトプットとかに使うつもり。

ここからさらにsvgで出力し、

カッティングプロッタでプラ板等に切り出し、

積層していくとか。

次は、ペパクラデザイナーのような展開図を作成するアルゴリズムに挑戦してみる。

三次元ボロノイ分割

2011-03-22T03:22:00.009+09:00

half-edgeデータ構造の勉強に、Frederik Vanhoutte氏のコードをFlashへ移植してみた。

三次元ボロノイ分割 - wonderfl build flash online

マウスプレスで母点追加、キープレスで更新のオンオフ

描画はテキトー
さらっと書くつもりが、完成間近で一度ミスってファイルを消したり、バグがとれなかったりで時間かかった。

おまけ

Voronoi 3D with PV3D - wonderfl build flash online

PV3Dにつっこんでみた。

Xcodeでパッケージにファイルがコピーされない

2011-03-18T06:01:00.003+09:00

cinder上でGLSLをいじっていて

warning: no rule to process file '$(PROJECT_DIR)/hoge/FlatShader.frag' of type sourcecode.glsl for architecture i386
warning: no rule to process file '$(PROJECT_DIR)/hoge/FlatShader.vert' of type sourcecode.glsl for architecture i386
warning: no rule to process file '$(PROJECT_DIR)/hoge/NormalMap.frag' of type sourcecode.glsl for architecture i386
warning: no rule to process file '$(PROJECT_DIR)/hoge/NormalMap.vert' of type sourcecode.glsl for architecture i386

という警告がでてパッケージに該当するファイルがコピーされなくなった。

左のカラムの”ターゲット”を開くと、”ソースをコンパイル”にGLSLのファイルが入っていたので、”バンドルリソースをコピー”にドラッグする。そうすると警告がでなくなり上手く動くようになった。

単純だけど、いきなりなって焦った。　.vertや.fragって前からこうだったかな？

XcodeでMacPortsのフォルダにインクルードパスを通す

2011-03-10T08:10:00.005+09:00

セットアップしたMacPortsを実際に使用してみる。ついでに、Xcodeでの使用方法もメモしとく。

とりあえず、Boostライブラリを例にする。
ターミナルから

sudo port install boost

とうつとインストールが始まるので、しばらく待つ。buildに時間がかかる。
これで、ライブラリのインストールは終了。

で、Xcodeでインストールしたライブラリを使用するには、インストール先である/opt/loaclまでのパスを設定してやればいい。

boostのヘッダーは/opt/local/include/に格納されているので、Xcodeのプロジェクト>プロジェクト設定の編集>ヘッダ検索パスに/opt/loacl/include/と追加する。

これで、Xcodeのプロジェクト上でboostが使用可能になる。

ついでに、Xcodeのグローバルパスの設定方法を調べてみた。
~/.MacOSX/environment.plistのHEADER_SEARCH_PATHSでヘッダ検索パス、USER_HEADER_SEARCH_PATHSでユーザヘッダ検索パスを設定できるらしいんだけど、ユーザヘッダ検索パスしか動かなかった。http://stackoverflow.com/questions/749027/how-to-add-a-global-include-path-for-xcode

とりあえず、手動でパスは設定していくとして、こっちの方法もあとで調べておくとしよう。

MacPortsのセットアップ手順

2011-03-10T07:01:00.002+09:00

MacPortsとはオープンソース・ソフトウェアを手軽にインストール、管理できるアプリのこと。
ソースを探し、ビルドし、アップデートする手間が省けてすごく楽ができる。

最近、友人に聞かれたので、改めてまとめてみる。

まず、MacPortsのサイトから、インストーラをダウンロードしインストールする。

次に、環境変数 PATHにMacPortsで使用するフォルダの場所を追加する。PATHとはコマンドラインで各種のコマンドを手軽に呼び出すための設定。
ターミナルを起動して、

echo 'export PATH=$PATH:/opt/local/bin:/opt/local/sbin/' >> ~/.bashrc 
echo 'export MANPATH=$MANPATH:/opt/local/man' >> ~/.bashrc 
echo 'source ~/.bashrc' >> ~/.bash_profile

と打ち込んだあと、ターミナルを再起動。

最後に、MacPorts自身をアップデートする。

sudo port selfupdate

といれて、パスワードをいれてやるとアップデートしてくれる。
※エラーで、javaのアップデートが必要とでた場合は、こちらを参照。
※学校だとmacports上手く動かない、gitもなんか変な動きするし。ポートかな

openframeworksでポリゴンを選択する方法

2011-03-05T09:45:00.009+09:00

前回のnurbsとhemeshを組み合わせて、なにか凝ったモノをつくろうとして挫折。そもそも、JOGLのnurbsが未実装だった。

というわけで、今回もTipsっぽい記事。openframeworkでポリゴンのマウスクリックや、マウスオーバーの判定を取る方法。

地道に座標を変換して照合していくことももちろん可能だが、openglにマウスピック用のAPIがすでに用意されているので、それを試してみた。

参考したのは以下のサイト

※カメラやライトの設定にofx3dutilsというアドオンを（あと、ofxVectorMathも）使用しています

testApp.h

#ifndef _TEST_APP
#define _TEST_APP

#include "ofMain.h"
#include "ofxEasyCam.h"
#include "ofxLight.h"
#include <iostream>
#include <vector>

#define FOV  60.0f
#define NEAR 1.0f
#define FAR  100.0f
#define BUFSIZE 512


class testApp : public ofBaseApp{

 public:
  void setup();
  void update();
  void draw();
  void mousePressed(int x, int y, int button);
  void mouseReleased(int x, int y, int button);
  void windowResized(int w, int h);
  
  void drawBox(GLenum mode = GL_RENDER);
  void pick(int x, int y, std::vector<int>& hitList);
  void selectThisSide(GLuint hits, GLuint *buf, std::vector<int>& hitList);
 
  ofxEasyCam   cam;
  ofxLight   light;
  std::vector<int> selectedList;
 
 private:
  template<typename T> bool contains(std::vector<T>& hitList, T element){
   return std::find( hitList.begin(),hitList.end() , element )!= hitList.end(); 
  }
};

#endif

testApp.cpp

#include "testApp.h"

//--------------------------------------------------------------
void testApp::setup(){
 ofBackground( 0, 0, 0);
 glEnable(GL_DEPTH_TEST);
 
 // init camera /////////////////////////////////////////////
 cam.setOrigin(OF_ORIGIN_ZERO);
 cam.perspective(FOV, (float)ofGetWidth()/(float)ofGetHeight() , NEAR, FAR);
 cam.position(10.0f, 10.0f, 10.0f);
 cam.eye(0.0f,0.0f,0.0f);
 cam.zoomSpeed  = 0.1;
 cam.panSpeed   = 0.1;
 
 // init light //////////////////////////////////////////////
 light.pointLight(255, 255, 255, 0, 5, 0);
 ofxSetSmoothLight(true);
 ofxLightsOn();
 light.on();
}

//--------------------------------------------------------------
void testApp::update(){

}

//--------------------------------------------------------------
void testApp::draw(){
 cam.place();
 drawBox(); 
}

//--------------------------------------------------------------
void testApp::drawBox(GLenum mode){
 glPushMatrix();
 //ネームスタックを空にする
 if (mode==GL_SELECT) glInitNames(); 
 
 // box 1 /////////////////////////
 glTranslatef(3.0f, 0.0f, 3.0f);
 if (mode==GL_SELECT) {
  glPushName(1);
 } else {
  // 選択された状態であれば色を付ける
  if(contains(selectedList, 1)) ofSetColor(255, 255,   0);
  else       ofSetColor(255, 255, 255);
 }
 glutSolidCube(2.5f);
 if (mode==GL_SELECT) glPopName();
 
 // box 2 /////////////////////////
 glTranslatef(-3.0f, 0.0f, -3.0f);
 if (mode==GL_SELECT) {
  glPushName(2);
 } else {
  // 選択された状態であれば色を付ける
  if(contains(selectedList, 2)) ofSetColor(255,   0, 255);
  else       ofSetColor(255, 255, 255);
 }
 glutSolidCube(2.5f);
 if (mode==GL_SELECT) glPopName();
 
 // box 3 /////////////////////////
 glTranslatef(-3.0f, 0.0f, -3.0f);
 if (mode==GL_SELECT) {
  glPushName(3);
 } else {
  // 選択された状態であれば色を付ける
  if(contains(selectedList, 3)) ofSetColor(  0, 255, 255);
  else       ofSetColor(255, 255, 255);
 }
 glutSolidCube(2.5f);
 if (mode==GL_SELECT) glPopName();
 glPopMatrix();
}

//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){
 pick(x, y, selectedList);
}

//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){
 selectedList.clear();
}

//--------------------------------------------------------------
void testApp::windowResized(int w, int h){
 cam.perspective(FOV, (float)w/(float)h , NEAR, FAR);
}

//--------------------------------------------------------------
void testApp::pick(int x, int y, std::vector<int>& hitList){
 GLuint selectBuf[BUFSIZE];
 GLint hits;
 
 // ビューポートの情報を習得する
 GLint viewport[4];
 glGetIntegerv(GL_VIEWPORT, viewport);

 // ピックした結果を保存するバッファ
 glSelectBuffer(BUFSIZE, selectBuf);
 // 描画モードの切り替え
 glRenderMode(GL_SELECT);
 glMatrixMode(GL_PROJECTION);    
 // gluPickMatrixは射影変換行列を変更するため変更前の行列をスタックに保存する
 glPushMatrix();
 glLoadIdentity();
 // 第３,4引数はそれぞれx,yのピックアップの判定領域
 gluPickMatrix(x,viewport[3]-y, 5.0,5.0, viewport);
 // 変更された射影変換行列をもとにもどす。
 gluPerspective( FOV, (float)viewport[2]/(float)viewport[3], NEAR, FAR );
 glMatrixMode( GL_MODELVIEW );
 drawBox(GL_SELECT);                    
 glMatrixMode(GL_PROJECTION);
 glPopMatrix();
 glMatrixMode( GL_MODELVIEW );
 // 元の描画モードに戻す　返り値にヒットした数が返る
 hits = glRenderMode(GL_RENDER);
 
 hitList.clear();
 hitList.resize(hits);
 if(hits) selectThisSide(hits, selectBuf, hitList);
}

//--------------------------------------------------------------
void testApp::selectThisSide(GLuint hits, GLuint *buf, std::vector<int>& hitList){
 unsigned int i, j;
 GLuint names, *ptr, minZ,*ptrNames, numberOfNames=0;
 ptr = (GLuint *) buf;
 minZ = 0xffffffff;
 for (i = 0; i < hits; i++) { 
  names = *ptr; // ヒットしたデータの要素数を格納
  ptr++;   // ポインタはデプスの最小値を指す
  if (*ptr < minZ) {
   numberOfNames = names; // 要素数を更新
   minZ = *ptr;   // 最小値を更新
   ptrNames = ptr+2;  // ヒットしたデータ中の識別番号の先頭を格納する
  }
  ptr += names+2; // 次のヒットデータへ
 }
 
 ptr = ptrNames;
 std::string str = "The closest hit names are " ;
 for (j = 0; j < numberOfNames; j++,ptr++) {
  str += ofToString((int)*ptr) + " ";
  selectedList.push_back((int)*ptr);
 }
 std::cout << str << endl;
 
}

マウスプレス時にglRenderMode(GL_SELECT)で描画モードを選択モードへ変更、glPushNameでポリゴンに名前をつけて描画する。
そこから、gluPickMatrixでマウス座標上のデプスバッファを利用しヒットしたポリゴンの名前と深度情報を取り出す。
もし、ポリゴンが重なっていた場合、取り出した深度情報をもとに一番手前のものを選択する。というような流れ。

ヒットした情報を取り出すところまでは簡単だけど、取り出した情報がちょっと複雑。
~~上手くまとめられる気がしないので~~詳しくは上記のサイトのセレクションバッファの項の図を参照してください。すごく分かりやすい。

Cinder上でnurbsを描く

2011-03-02T01:46:00.007+09:00

普通にcinder上でopenglのgluNurbsSurfaceを使ってみただけ。特に変わったことはしてないけど、nurbs自体をはじめてさわったので、メモ。

openglのnurbsをcinder上で使用する。

参考にしたサイトは以下。

コードはこちら(study_NurbsApp.cpp)
※SimpleGUIをいれておく必要あり
例のごとく、上のサイトからコピペしていろいろいじくり回しただけだけど。

気になった点は、軽量化のためnurbsをdisplayListにいれようとした時、デフォルトで設定されてるテッセレーションの挙動がおかしくなったところ。もともと、分割されすぎて重く感じてたので

gluNurbsProperty(nurbs, GLU_SAMPLING_METHOD,  GLU_OBJECT_PATH_LENGTH);

で切っておいた。

あと、ノットベクトルはここを参照。エセ理系の自分にはちょっとキツイ。とりあえず、制御点数+次数だけの要素数をもつ配列をつくり、要素を単純増加させてやればよさそう。例えば、制御点数6、次数4のときノットベクトルは

GLfloat knot1[10]={0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0};
GLfloat knot2[10]={0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0};

とか、

GLfloat knot1[10]={0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
GLfloat knot2[10]={0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};

にしてやる。左から右に増加さえしていれば動くはず。

object_poolのdestroy()がなんだか遅い

2011-02-28T04:31:00.008+09:00

object_poolでメモリを確保したshared_ptrをvectorに大量に追加し、clear()で解放しようとした際、フリーズしたかと思うほど時間がかかったので検証してみた。

どうやら、destroy()の中で使われているordered_free()がなんかのタイミングでオーバーヘッドになってるっぽい。

以下、無駄に長い検証用コード。

#include <iostream>

#include <boost/shared_ptr.hpp>

#include <boost/pool/pool.hpp>
#include <boost/pool/object_pool.hpp>

#include <new>
#include <vector>

#include <time.h>
#include <sys/time.h>

using namespace std;
using namespace boost;

class testClass {
public:
 testClass() {}//cout<<"constructer"<<endl;}
 ~testClass(){}//cout<<"destructer"<<endl;}
};

//使用するpool,object_pool
pool<> p(sizeof(testClass));
object_pool<testClass> op;

// 時間計測用
double gettimeofday_sec()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec + (double)tv.tv_usec*1e-6;
}

// pool malloc ////////////////////////////////////////
inline testClass* malloc_pool()
{
 testClass* temp = (testClass*)p.malloc();
 if (!temp) throw std::bad_alloc(); 
 return new(temp)testClass();     
}

// pool free //////////////////////////////////////////
inline void free_pool(testClass *ptr)
{
 ptr->~testClass();
 p.free(ptr);
}

// pool ordered_malloc ////////////////////////////////
inline testClass* malloc_pool_ordered()
{
 testClass* temp = (testClass*)p.ordered_malloc();
 if (!temp) throw std::bad_alloc(); 
 return new(temp)testClass();     
}

// pool ordered_free //////////////////////////////////
inline void free_pool_ordered(testClass *ptr)
{
 ptr->~testClass();
 p.ordered_free(ptr);
}

// object_pool construct //////////////////////////////
inline testClass* construct_object_pool()
{
 return op.construct();
}

// object_pool construct //////////////////////////////
inline void destroy_object_pool(testClass *ptr)
{
 op.destroy(ptr);
}

typedef boost::shared_ptr<testClass> shPtr;

// テスト用　object_poolでメモリ確保、解放を行うshared_ptrを生成
inline shPtr createShPtr()
{
 return shPtr(construct_object_pool(),destroy_object_pool);
}

// 後ろの要素から解放するclear
inline void clear_reverse(vector<shPtr> &v)
{
 vector<shPtr>::reverse_iterator rItr   = v.rbegin();
    vector<shPtr>::reverse_iterator rSentinel = v.rend();
 //ややこしい!
 while(rItr != rSentinel){
  rItr = vector<shPtr>::reverse_iterator(v.erase((++rItr).base()));
 }
}

/////////////////////////////////////////////////////////////////////////////
int main () {
    int max_count = 100000;
 double start, end;
 
 // 比較用　ふつーに new delete ////////////// 
 start = gettimeofday_sec();
 {
  testClass* tps[max_count];
  for (int i = 0; i < max_count; i++){
   tps[i] = new testClass();
  }
  for (int i = 0; i < max_count; i++){
   delete tps[i];
  }
 }
 end   = gettimeofday_sec();
 printf("%f new delete\n", end - start);
 
 // pool malloc free /////////////////////
 start = gettimeofday_sec();
 {
  testClass* tps[max_count];
  for (int i = 0; i < max_count; i++){
   tps[i] = malloc_pool();
  }
  for (int i = 0; i < max_count; i++){
   free_pool(tps[i]);
  }
 }
 end   = gettimeofday_sec();
 printf("%f pool malloc() free()\n", end - start);
 
 // pool ordered_malloc ordered_free /////
 start = gettimeofday_sec();
 {
  testClass* tps[max_count];
  for (int i = 0; i < max_count; i++){
   tps[i] = malloc_pool_ordered();
  }
  for (int i = 0; i < max_count; i++){
   free_pool_ordered(tps[i]);
  }
 }
 end   = gettimeofday_sec();
 printf("%f pool ordered_malloc() ordered_free()\n", end - start);
 
 // pool ordered_malloc ordered_free 逆順に解放
 start = gettimeofday_sec();
 {
  testClass* tps[max_count];
  for (int i = 0; i < max_count; i++){
   tps[i] = malloc_pool_ordered();
  }
  for (int i = max_count - 1; i >= 0; i--){
   free_pool_ordered(tps[i]);
  }
 }
 end   = gettimeofday_sec();
 printf("%f pool ordered_malloc() ordered_free() reverse\n", end - start);
 
 // object_pool construct destroy ///////
 start = gettimeofday_sec();
 {
  testClass* tps[max_count];
  for (int i = 0; i < max_count; i++){
   tps[i] = malloc_pool_ordered();
  }
  for (int i = 0; i < max_count; i++){
   free_pool_ordered(tps[i]);
  }
 }
 end   = gettimeofday_sec();
 printf("%f object_pool construct() destroy()\n", end - start);
 
 // object_pool construct destroy 逆順に解放///////
 start = gettimeofday_sec();
 {
  testClass* tps[max_count];
  for (int i = 0; i < max_count; i++){
   tps[i] = malloc_pool_ordered();
  }
  for (int i = max_count - 1; i >= 0; i--){
   free_pool_ordered(tps[i]);
  }
 }
 end   = gettimeofday_sec();
 printf("%f object_pool construct() destroy() reverse\n\n", end - start);
 
 // object_pool vector<shared_ptr> clear() ////////////////
 start = gettimeofday_sec();
 {
  vector< shPtr > vec;
  vec.reserve(max_count);
  for (int i = 0; i < max_count; i++){
   vec.push_back(createShPtr());
  }
  vec.clear();
 }
 end   = gettimeofday_sec();
 printf("%f object_pool vector<shared_ptr> clear()\n", end - start);
 
 // object_pool vector<shared_ptr> clear_reverse() ////////////////
 start = gettimeofday_sec();
 {
  vector< shPtr > vec;
  vec.reserve(max_count);
  for (int i = 0; i < max_count; i++){
   vec.push_back(createShPtr());
  }
  clear_reverse(vec);
 }
 end   = gettimeofday_sec();
 printf("%f object_pool vector<shared_ptr> clear_reverse()\n", end - start);
    return 0;
}

実行結果

0.019162 new delete
0.001466 pool malloc() free()
3.160949 pool ordered_malloc() ordered_free()
0.000657 pool ordered_malloc() ordered_free() reverse
8.477591 object_pool construct() destroy()
0.000578 object_pool construct() destroy() reverse

7.018725 object_pool vector<shared_ptr> clear()
0.018434 object_pool vector<shared_ptr> clear_reverse()

ordered_freeのコードを見てないのでなんともだけど、メモリを確保した順に解放しようとするとものすごく時間がかかる模様。名前から察するに後ろから解放していけばいいんじゃね？的な勘でやってみたら上手くいった。

暇なときに、poolのアルゴリズムに目を通しておきたいですね。

shared_ptrとintrusive_ptrをメモリプールをつかって高速化してみる

2011-02-27T05:03:00.013+09:00

引き続き、C++のメモリ動的確保の話。
shared_ptrをどうしても高速で扱えるようになりたかったので、メモリプールを組み合わせて試してみた。

まんまこちらのサイトを参考にさせてもらった。

#include <iostream>
#include <boost/intrusive_ptr.hpp>
#include <boost/shared_ptr.hpp>

#include <boost/pool/pool.hpp>
#include <new> // std::bad_alloc用

#include <time.h>
#include <sys/time.h>

class testClass {
private:
 static boost::pool<> p;
 
public:
 testClass():refCount(0) {}
 ~testClass()   {}
 
 static inline boost::intrusive_ptr<testClass>  createInPtr()
 {
  return boost::intrusive_ptr<testClass>(new_testClass());
 }
 
 static inline boost::shared_ptr<testClass>     createShPtr()
 {
  //第二引数でdelete用の関数を渡せる
  return boost::shared_ptr<testClass>(new_testClass(),testClass::delete_testClass);
 }
 
 static inline testClass* new_testClass()
 {
  testClass* temp = (testClass*)p.malloc();
  if (!temp) throw std::bad_alloc(); //　メモリ確保に失敗した際、poolは0を返すため例外はこちらで投げとく
  return new(temp)testClass();       // 配置new
 }
 
 static inline void delete_testClass(testClass *ptr)
 {
  ptr->~testClass(); // freeはデストラクタを呼んでくれないため自前で呼ぶ必要あり
  p.free(ptr);
 }
 
private:
 
 // intrusive_ptr用 参照カウンタ
 int refCount;
 
 // intrusive_ptr用 参照が増えた時呼ばれる処理
 friend void intrusive_ptr_add_ref( testClass* ptr )
 {
  ptr->refCount++; 
 }
    
 // intrusive_ptr用 参照が減った時呼ばれる処理 参照が0になるとdeleteが呼ばれる。
 friend void intrusive_ptr_release( testClass* ptr )
 { 
  ptr->refCount--;
  if (ptr->refCount <= 0) delete_testClass(ptr);
 }
 
};

// pool の初期化
boost::pool<> testClass::p(sizeof(testClass));

typedef boost::intrusive_ptr<testClass> inPtr;
typedef boost::shared_ptr<testClass> shPtr; 

// 時間計測用
double gettimeofday_sec()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec + (double)tv.tv_usec*1e-6;
}

int main () {
 int max_count = 1000000;
 double start, end;
 
 // 比較用　ふつーに new delete ////////////// 
 start = gettimeofday_sec();
 for (int i = 0; i < max_count; i++){
  testClass *tp = new testClass();
  delete tp;
 }
 end   = gettimeofday_sec();
 printf("%f new delete\n", end - start);
 
 // shared_ptr /////////////////////////// 
 start = gettimeofday_sec();
 for (int i = 0; i < max_count; i++){
  shPtr tcShp = testClass::createShPtr();
 }
 end   = gettimeofday_sec();
 printf("%f shared_ptr\n", end - start);
 
 // intrusive_ptr ///////////////////////
 start = gettimeofday_sec();
 for (int i = 0; i < max_count; i++){
  inPtr tcInp = testClass::createInPtr();
 }
 end   = gettimeofday_sec();
 printf("%f intrusive_ptr\n", end - start);
 
    return 0;
}

実行速度は以下の通り

0.060343 new delete
0.080444 shared_ptr
0.003590 intrusive_ptr

intrusive_ptrに関してはかなり高速。
shared_ptrは上記のサイトにあるように参照カウンタ分のオーバヘッドが残っているため通常のnew deleteとトントンくらい。

intrusive_ptrの速度は魅力的だが、shared_ptrと対でつかうweak_ptrを使用したいのでこれで我慢しとく。

この書き方だと、メモリはrelease_memory()を呼んでやらない限りプールされ続ける。そのため、数回しかそのクラスを使わない場合は、メモリ効率が良くなさそう。けど、毎フレーム大量かつ一定の量クラスのメモリ確保と解放を行うような場合は使えそうだ。

あと、現時点でスレッドセーフという考え方を全く理解してないため、上のコードも安全かどうかさっぱり分かってない。そういった理由から、singleton_poolより単純に早かったstaticなpoolを使ってたりする。まあ、もう少し勉強したらもう一回チャレンジしてみよう。

shared_ptrとintrusive_ptrの実装方法とかパフォーマンスとか

2011-02-27T03:48:00.003+09:00

最近、C++のメモリの動的確保や管理の方法についていろいろ調べまわっていたので、わかったことをメモしておく。

まずは、スマートポインタについて。

スマートポインタとは、登録したオブジェクトがどこからも参照されなくなったさい、自動でdeleteを呼んでくれる便利クラス。ガベージコレクションの実装された言語ばかりさわってた自分にとって、これはすごくありがたい。

shared_ptrやauto_ptr、intrusive_ptr等が存在するけど、今回はshared_ptrとintrusive_ptrの使い方とパフォーマンスを比較してみた。

#include <iostream>
#include <boost/intrusive_ptr.hpp>
#include <boost/shared_ptr.hpp>

#include <time.h>
#include <sys/time.h>

class testClass {
 
public:
 testClass():refCount(0) {}
 ~testClass()   {}
 
 static inline boost::intrusive_ptr<testClass>  createInPtr()
 {
  return boost::intrusive_ptr<testClass>(new testClass());
 }
 
 static inline boost::shared_ptr<testClass>     createShPtr()
 {
  return boost::shared_ptr<testClass>(new testClass());
 }
 
private:
 
 // intrusive_ptr用 参照カウンタ
 int refCount;
 
 // intrusive_ptr用 参照が増えた時呼ばれる処理
 friend void intrusive_ptr_add_ref( testClass* p )
 {
  p->refCount++; 
 }
    
 // intrusive_ptr用 参照が減った時呼ばれる処理 参照が0になるとdeleteが呼ばれる。
 friend void intrusive_ptr_release( testClass* p )
 { 
  p->refCount--;
  if (p->refCount <= 0) delete p;
 }
 
};

typedef boost::intrusive_ptr<testClass> inPtr;
typedef boost::shared_ptr<testClass> shPtr; 

// 時間計測用
double gettimeofday_sec()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec + (double)tv.tv_usec*1e-6;
}

int main () {
 int max_count = 1000000;
 double start, end;
 
 // 比較用　ふつーに new delete ////////////// 
 start = gettimeofday_sec();
 for (int i = 0; i < max_count; i++){
  testClass *tp = new testClass();
  delete tp;
 }
 end   = gettimeofday_sec();
 printf("%f new delete\n", end - start);
 
 // shared_ptr /////////////////////////// 
 start = gettimeofday_sec();
 for (int i = 0; i < max_count; i++){
  shPtr tcShp = testClass::createShPtr();
 }
 end   = gettimeofday_sec();
 printf("%f shared_ptr\n", end - start);
 
 // intrusive_ptr ///////////////////////
 start = gettimeofday_sec();
 for (int i = 0; i < max_count; i++){
  inPtr tcInp = testClass::createInPtr();
 }
 end   = gettimeofday_sec();
 printf("%f intrusive_ptr\n", end - start);
 
    return 0;
}

実行速度はこんな感じになった

0.065289 new delete
0.178643 shared_ptr
0.059417 intrusive_ptr

shared_ptrがかなり遅い。内部で参照カウンタをnewしてるせいか。
てか、new delete自体も意外なほどマイペース。

メモリプールをつかってパフォーマンスの改善を試してみたので次回にまとめる。

bloggerでSyntaxHighlighter

2011-02-26T18:00:00.012+09:00

手始めに記事上のコードを見やすくするために、SyntaxHighlighterを導入してみる。

いろいろやり方はあるみたいだけど、今回はこちらの方の記事を参考にさせてもらった。
使用したい言語を追加しつつ、headタグ内に以下のコードをペースト

<!--start SyntaxHighlighter--> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js' type='text/javascript'></script> 
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shAutoloader.js' type='text/javascript'></script> 
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shCore.css' rel='stylesheet' type='text/css'/> 
<link href='http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css' rel='stylesheet' type='text/css'/> 
<script type='text/javascript'> 
  window.onload = function() {
  SyntaxHighlighter.autoloader(
      "js jscript javascript    http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJScript.js"
     ,"bash shell               http://alexgorbatchev.com/pub/sh/current/scripts/shBrushBash.js"
     ,"css                      http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCss.js"
     ,"html xml xhtml           http://alexgorbatchev.com/pub/sh/current/scripts/shBrushXml.js"
     ,"cpp c                    http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCpp.js"
     ,"java                     http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJava.js"
     ,"actionscript3 as3        http://alexgorbatchev.com/pub/sh/current/scripts/shBrushAS3.js"
     ,"php                      http://alexgorbatchev.com/pub/sh/current/scripts/hBrushPhp.js"
  );
  SyntaxHighlighter.all();
};
</script> 
<!--end SyntaxHighlighter-->

これで準備完了。あとは、投稿画面のHTMLの編集で、コードを以下のようにpreタグで囲ってやる。
brush:のあとのhogeに言語に対応した名称を入れてやればいい。

<pre class="brush:hoge">
コードを記述...
</pre>

あと、htmlの記述にこちらの変換ツールを使用させてもらった。便利。

jsをアップロードしておきたいんだけど、どこにおけばいいんだろ？

このブログについて

2011-02-25T16:18:00.001+09:00

プログラミングの勉強、メモ用にブログを使ってみることにした。

基本的にopenframeworksやcinder、processingのようなメディアアート系のフレームワークについての個人的メモを置く場所となる予定。

てきとーなこと書いて、だれかに優しく正してもらう、そんなブログにしたい。