ビット演算

厨房くさいトリッキーな高速化テクニックを集めてみませんか？

format >>1

例えば、
下位5ビットを0埋めする場合。

a = ( a >> 5 ) << 5;
a &= ~(( 1 << 5 ) - 1);

0-n を繰り返す。
nは2のべき乗-1

++a &= n;

Hacker's Delight
ttp://www.hackersdelight.org/

ハッカーのたのしみ―本物のプログラマはいかにして問題を解くか
ttp://www.amazon.co.jp/exec/obidos/ASIN/4434046683

0と1を繰り返す。
a = 0;

a ^= 1;

一番下位の1になってるbitだけを取り出す

flag = bitmap & ((~bitmap)+1)

bitmap = 0xfffff000 の時 flag は 0x1000 になる。

>>7
それは厨房くさくないのでスレ違い

x<<n == (2^n)x

例えば、
下位5ビットを0埋めする場合。

a = ( a >> 5 ) << 5;
a &= ~(( 1 << 5 ) - 1);

int max(int a, int b) {
int m = (a - b) >> 31;
return ((a ^ b) & m) ^ a;
}
あってるかな？？

"Hello,World!\n"を書くつもりで、あなたの一番好きな
言語でCRC16を書いてください。

std::cout << "CRC16";

>>13
おまえ、馬鹿じゃねぇの？
俺が正しい見本を書いてやる！

std::cout << "CRC16" << std::endl;

ビット演算マニアになれる書籍を教えてください。

それは欲しいなｗ

しかしベッチ演算の面白さは自分で考えることにある。
面白いテクニックを発見した時は射精に至ることも多々。

>>15
読んだ中ではHacker's Delight（邦訳：ハッカーのたのしみ）以上の本は無い

>>17
ありがとうございました。
つ -●◎○-

xorによる値の交換

int a = 123, b = 234;
a ^= b; b ^= a; a ^= b;
printf("a = %d, b = %d\n", a, b);

#define ROUNDUP(x,u) (((x) + (u) - 1) & ~((u) - 1))
xをuの単位に切り上げる。
uは2のべき乗でなければならない。

>>19
それは普通のスワップより高速ですか？

>>21
メモリの使用量で有位かな？

速さはそうでもないという事ですか。
カリカリチューニング用コードですか。

テンポラリ変数を宣言する手間が省ける。

では速度でも省メモリでも優位という事でよろしいですか？

>>21 演算の並列化ができないから遅い。
>>22 レジスタ使えよ
>>23 むしろ劣化
>>24 STLのstd::swapでも使って露
>>25 だから遅いってばよorz

>>26
Hacker's Delight読め。

>>27

a ^= b; ・・・（１）
b ^= a; ・・・（２）
a ^= b; ・・・（３）

（２）は（１）の演算が終わるまで、（３）は（２）が終わるまで実行できない。だから3クロックかかる。
これがいわゆる依存関係ってやつで、モダンなCPUアーキテクチャでは好まれない。

t = a; 　・・・（１）´
a = b;　・・・（２）´
b = t;　・・・（３）´

これなら、ALUが2個以上有る場合、（１）と（２）、もしくは（２）と（３）を並列実行できるから2クロックほどで済む。

もっとも1インストラクション1クロックという前提の話だけど。

おっと、下のはただの代入演算だからALUは使わないや

Modern CPU kills the bit calculation.

ビット演算に関係する数学ってどんなの？ブール代数以外で。

ζ関数

>>32
ζ関数をCで書いてみてください

#include <stdio.h>
int main(void) { printf("ζ関数\n"); return 0; }

いつからだろう？↑こういう発想が出来なくなったのは。

一時変数宣言して変数値交換しても
最適化でレジスタに割り振られるから
ビット演算よりも高速ってこと？

最近のCPU（i586以降）だと無意味どころか
有害なビット演算って>>28以外にどういうのがあるの？

>>36
例えば乗算の代わりにビットシフトを使うと、CPUによっては却って遅くなる。

>>37
ということは、nビットシフトを2**n乗算に置き替えるのがモダンなビット演算だね

シフトより乗算が高速。どんなCPUなんだそれは。

5回シフトするよりも1回の乗算ってこと？

シフトする回数増えるとその分遅くなるもんなの？
誰か教えて。お願い。

そういうプロセッサもあった。
例えばx86系ならば、8086-80286までは多ビットシフトの演算器を持っておらず
1bitシフトを繰り返していたため、時間がかかった。

80386以降は、バレルシフタというもの(結構面積を取るらしい)が組み込まれたので
何ビットシフトしようと、同一クロックで処理できるようになった。
ただし、32bit以上のシフトはマスクされるようになった。

と、どっかの本に載ってた。

>>42
そんなCPUで積算が高速に実行できるとでも？

>>43
んなもんCPUの実装による

>>44
そうだけど、脳内CPUじゃなくてさー、実例を挙げてくれよー

実例を挙げられないのはお互い様

16bit整数の乗算は8086 (8 MHz)で約15 us、80286 (6 MHz)で3.5 usだそうだが？

というわけで実例よろ
なんだかんだ言い逃れして絶対に挙げないのは分かってるけど

馬鹿？

ほらね

　　　　　　　☆ ﾁﾝ

　☆　ﾁﾝ　　〃　∧＿∧ 　 ／￣￣￣￣￣￣
　　ヽ　＿＿_＼（＼・∀・）＜　実例ﾏﾀﾞｰ？
　 　 　 ＼＿／⊂　⊂＿)＿ ＼＿＿＿＿＿_
　 　 ／￣￣￣￣￣￣￣／|
　　 | ￣ ￣￣￣￣￣￣:|　 |
　　 |　Intelはいってる　.|／
　　 ￣￣￣￣￣￣￣￣

>>43は明日中に実例出すように。

じゃなきゃトンズラと見なしますんで。

>>52
勝手にどうぞ。
独りで高らかに笑っててください。捕まらん程度に。

捨て台詞に水を差すようで悪いが悪いが笑うのは少なくとも二人だぞ？

少なくとも三人。一人なのはむしろそっちだということにも気付いてないのか
哀れな

先に実例とか言い出すほうが実は何の根拠も無くレス書いてる
（何か言いたげなのに何故か他人に書かせることばかり必死なのはそのせい）
というのはもうお約束だな。

>37
>例えば乗算の代わりにビットシフトを使うと、CPUによっては却って遅くなる。
で、こういうCPUは存在するのか？

ビットシフトが複数回に分割されるCPUなんて今時ないからなぁ。
じゃあ昔はどうだったかって考えても、高速乗算回路じゃBoothのアルゴリズムを
使ってたんだから乗算するのにそもそもシフト使ってるわけで。
最近の乗算はどうやってるんだろうな。Boothはもう使ってないのか？

「？」ばっかだな。
実例を出さない代わりにねちっこい質問を延々相手にぶつけ続けて、
相手が自分を放置し次第、一度も実例を出さないまま「相手は逃げた。やっぱり俺は正しい」と
勝利宣言する作戦か。

>>58
ビットシフトが1ビットシフト命令しかない8086という16ビットCPUならまだ現役ですが何か？

>>59
させてやりな。それで彼に英知が身に付くわけでなし。

16倍するときに4ビットシフトするより
addを4回続けた方が早いCPUならまだ存在する。

leaの方が速そうな希ガス。

俺が待ち望んでいたスレはここですか？

ちがいます

年月日から曜日を出すトリッキーなやつなかったっけ？
ビット演算じゃなかったかも。

>>66
Zellerの公式のことかな？たしかにこれはビット演算ではないわけだが。
http://www.kumei.ne.jp/c_lang/intro/no_41.htm

x2 = (x1 * sin[dg]) - (y1 * cos[dg]);
y2 = (x1 * cos[dg]) - (y1 * sin[dg]);

な点の回転を掛け算使わずにシフトでやるとか見たような気がする。

http://www.entis.jp/doc/lolita_programing/lolita2.html

>>68
そもそも回転になってない式持ち出されても。
回転なら、
x2 = x1 * cos(dg) - y1 * sin(dg)
y2 = x1 * sin(dg) + y1 * cos(dg)
だと思うのだが。

で、要は三角関数をテーブル参照して、乗算をシフトでやるってこと?
精度が出そうにないし、8or16ビットCPU時代のゲームの話かな?

>>70
人をバカにするだけの人生に何の意味があるのか。

>>71
>70は馬鹿にしてないと思うのだが。それとも、あなたは被害妄想爆発の>68ですか?

>>68ではない気がする。
ただ誰かを叩きたくてうずうずしてるﾊﾟｰﾎﾟﾘﾝだろ（　´_ゝ`）

>>72
思うのは自由ですが、あまり自分の鈍くさい判断力を
他人に当てはめない方がいいですよ。

少なくとも>72の方が>74よりはましだったようだ。

>>74
(´･ω･｀)ｶﾜｲｿｽ

ひどい自作自演を見た気がする

>>11はif文を使うより高速ですか？

>>78
わかんね
今はif文の方が速いと思う
勘だけどな

>>78
ステップ数がどの条件でも同一という利点以外はないよ。

>>80
分岐が無いから、命令キャッシュが無駄にならない。

それだったらinline展開しないと勿体無いな。

>>57
実在するよ。
初期のSHは１，２，８とかの決まったシフト数しか左シフト出来なかったんで
シフトを組み合わせないといけなかったから。

DSP系だと、掛算は専用掛算器を持っているし
シフタもバレルシフタを持っているのだけど、
命令長の関係からシフトするのにレジスタをあちこち移動しなくちゃいけなくて
掛算した方が早いという場合がたまに出てくる。

>>78
書いて試してみればいいじゃない。
でも、Cだとコンパイラによるかもね。
(a - b) >> 31　をSUB+CWD命令に置き換えてくれるくらい賢いならいいんだけど

>>83
初期のSHってどこまで？

>>85
そんぐらい自分で調べろヴォケ屑！

>83
1,2シフトはわかるとしても、8シフトの中身は本当にシフト命令になってるんだろうか・・・？

淫乱展開

ウソクサイ

>>87
1，2，8，16のシフトはそれぞれ１サイクル命令
16x16の掛算も１サイクル命令（ただし結果を利用出来るのはさらに２サイクル後）

何の前置きもなくいきなりIA32の話をされてもむぅんって感じ。

いきなりIA32って・・・・このページの事？

ttp://www.tensyo.com/urame/prog/ALGO.HTM
より
/************************************************************
符号無し同士の加算をし、結果がオーバフローしたら最大値にする
unsigned ClipAddUU(unsigned a,unsigned b)
{ unsigned c=a+b;
if(c>=a && c>=b) return c;
return (unsigned)-1;
}
************************************************************/
unsigned ClipAddUU(unsigned a,unsigned b)
{
unsigned c;
_asm {
mov eax,a ;
add eax,b ;
xor ecx,ecx;
sbb ecx,0 ;
or eax,ecx ;
mov c,eax; /*帰値はeaxなので不要だが警告を黙らせる為*/
};
return c;
}

nakedを知らんのか

naked（･∀･）ｲｲ

このスレらしく無駄にビット演算使ってみるとこんな感じか。

unsigned ClipAddUU(unsigned a,unsigned b)
{
    unsigned c=a+b;
    return c|-(c<(a|b));
}

>>93 2000年って事だから　__declspecそのものが無かったような・・・・

このスレはトリッキースレと被ってるけど、まあいいか。
為になりそうでならないところがいい。

>>96
そんなこたない

アセンブラで書くなら、JCの方がコードは短いだろ

 

>>62
Pentium4のことかぁぁぁ

あれは上下16ビットに分かれててタイミングずらして演算するからね。
単純なビット論理や加減算なら1命令0.5クロックだけどシフトは４クロック
だったような。Prescottはよく知らないけど。

ビット演算は不毛なんでしょうか

http://www.darkside.com.au/bitslice/nonstd.c

のs2関数をAltiVecの AND / AND-NOT / OR / NOR / XOR で構成し直して
50ゲート以内に納めたら神認定。

「ハッカーのたのしみ」以外にビット演算について詳しく書かれた本はありますか？

俺が持ってる本でビット演算について触れてるのは
やねうらおの「Windowsプロフェッショナルゲームプログラミング」
って本かな。
MMXを使わずにアンパック演算やサチュエーションとか
整数ALU／レジスタで小数として使う方法とか載ってるけど
ゲームに関わらずWindowsでC/C++な人は読んでみると良いかも。

あと、Hacker's Delight公式サイトにそれなりの有用なリンクがあるよん。

この本の日本語版が出たのって某東大生のページで取り上げられてから
１年くらい後だったな。

>>105
ビット演算に触れてるのは、「Windowsプロフェッショナルゲームプログラミング2」のほう

>>105-106
レスありがとうございます。

もう終わりか…

終わっちゃうなんていやいや＞＜

【拷問ビデオ】恋人がAVに出演してた【許すな！これはAVじゃない】
http://ex10.2ch.net/test/read.cgi/news4vip/1130499649/

Pentium4では、シフト命令よりadd命令が早いそうだ
何と、シフト1命令とadd8命令が同じ速さ
http://www.marumo.ne.jp/db2002_7.htm#25

「何と」っつー程の話じゃないな。

内部で同じμopに変換されてるってだけの話じゃないの

>>111
それなりに有名かもしれないけど128倍までならadd %eax, %eaxの方が速いってことだよね。
「変態」なだけで自慢できることじゃないけど。プレスコだとこれまで0.5サイクルだったのが
1サイクルになってしまったのであまり意味内。

むしろシフトが4クロックもかかるのが異常。
左シフトはそれでいいかもしれないけど右シフトはやっぱり4クロックかかるわけで。

やっぱPentium Mのほうが立派だわな。

シフトは足し算より掛け算にした方が早い

>>116
多ビットシフトで掛け算が一番速いのってプレスコか？
いや、さすがにレイテンシ４のシフトのが速いだろ。

そんなのはベタなネタだって。
乗算がシフトより早いなんてありえないじゃん。
IMUL　 レイテンシ　14　　 　スループット　3
MUL 　レイテンシ　14-18　 スループット　5

バレルシフタがないCPUならありえるかもね。SH1とか？

>>119
ｶﾞｲｼｭﾂ

>>119
SH1/2/DSPマニュアルでは、
　シフト命令　1ステート
　乗算 　　　　1(2)〜3(4)ステート
ってあり、これはSH1でも変わらない。
DSPからバレルシフタは載ってるけど。

>>121
ということは4bit以上シフトするなら乗算の方がいいのか

>>122
ちがうって。
1、2、8から4つ以上を重複組合せで取って合計しないと表せない数で
シフトを行う時は乗算が絶対速い。
逆に3つ以内だとシフトのほうが早い可能性がある。
具体的に挙げていくと
・1つで済む
　　1、2、8
・2つで済む
　　3、4、6、7、9、10、16
・3つで済む
　　5、11、12、14、15、17、18、24
てな感じでSH1/2の実用的な範囲では13以外は表せる。

それは、乗算の代わりにシフトで実現する場合の話だね。
今問題にしてるのは、
シフトの代わりに乗算を使った方が早いっていうCPUがあるのか？
だと思ってたけど。

シフト数が変数だったらどうするのかな。
やはりシフト用実行時ルーチンを読んで、中で分岐か。
13とか19は掛け算になってるのかな。

>>122
いやーその通り。
SH-1のシフト・ローテイト命令は
1bitシフト
8bitシフト
16bitシフト
しか無い。

x86系は定数の掛け算ならLEAのが速いような。
アドレス生成ユニット使うから、ALUで実行する別の命令と並列化できる。

あるバッファを高速にゼロクリアして、さらにゼロになっているかかくにんするプログラムを作りたい
けど、とにかく高速に処理をしたいと思っています。
何か良い方法はありますか？

使っているのはSH-2の7145です。

とりあえず、RAMに0を代入して、その領域と任意の変数（初期値0）とORしていき、次のRAMをクリア。
最終的にその任意の変数が0になっているかを確認という方法をとっています。

何で代入しているのに確認しないといけないのかよくわからんなぁ。

ゼロクリアって言ったら昔こんなのなかったっけ？

xor eax, eax

たしか
mov eax, 0
より高速だとか聞いたけど。
SH1でどうかは知らん。

>>128
よく状況がわからんけど、
もしメモリマップドI/Oのレジスタ操作なら、ターゲットのI/Oの仕様を確認して
必要なウェイト数だけ待たなければならない。
そうでなく単なるRAMなら0になった確認など要らないと思う。

>>129-130
ネタに釣られないように。
制御系関連のスレで同じ質問見たことある。

＞何で代入しているのに確認しないといけないのかよくわからんなぁ。

ようは、きちんと任意のRAMがクリアされているかの確認です。
仕様上、確認するようにとのことです。

もう少し、他に例を挙げるなら、電源投入時にRAMのチェックってやりますよね？
（0xAAAAAAAAや0x55555555など書き込んでチェック）
あれを速くする方法などありますか？

メモリテストなら、0を書き込むのはあまり意味が無い。
なぜ、Aと5を書き込むのかよく考えれ。

0x00 より 0xAA や 0x55 の方が良い理由を述べてください。

>>134
ＲＡＭが壊れてても、0xFFか0x00返すからな。

もっと言うと、アドレスの下位ビットが同じ場所には別のアドレスの情報が転写されてる場合（アドレス線のショート）もあるから、２の倍数じゃない単位で書き込む内容を変化させるといいよ。
そうそう、データ線のショートのチェックもしたいなら、１ビットづつシフトさせて書き込みチェックな。

アドレッシングも何パターンか変えて試行しろ。

>>135
まあ、データバッファとかが壊れたらそうだろうけど、メモリセルの一ビット
故障だと 0x55/0xAA が特に優れてるわけじゃないよね。

>>136
> アドレスの下位ビットが同じ場所には別のアドレスの情報が転写されてる場
> 合

落ち着いて、日本語をしゃべれよ。

> 落ち着いて、日本語をしゃべれよ。

十分日本語だぜ？
わからねえ奴には何言ってもわからねえらしいな。

まあメモリセルのアドレス線配置を調べて（カラム、ロー）、その同じロー、カラム線化けを
逃さないようにアクセスすることも考えるべきかな。

>>136
データ線の影響なら、最下位ビットとその他のビットのエラーになる確率は変わらないと思うよ。

>>138
メモリーセルの１ビットの故障を調べるなら、なおさら0x00なんかより、0x55と0xAAを何回か書き込んでみる方がよっぽどマシだぞ。

>>138
でもまあ他のパターンよりかは、5とAを交互に行うのが一番効率は良いよね。
俺は、0とFのパターンとか、特定ビットだけが違う(例 E, D, B, 7とその反転）のも行うけど。

最近はキャッシュなんてやっかいなものがあるから、
キャッシュあり・なし（ミスヒット）パターンなんてのもやらないと意味がない。

>>139
ハイハイ、俺様日本語ね。
おまえがアフォだということだけは、伝わったよ。(w

>>141-142
だから、なぜ 0x55, 0xAA がいいのか理由を書いてよ。

>>144
ヒント：２進数表記

2進数で考えれ。
それでも判らないのなら、H/Wのお勉強をしろ。

>>144
>>138以降のやりとりを見ててだな、
お前以外はみんな言ってる意味が判ってるとは思わんか？
そこに噛み付いてるのはお前だけだろが。

>>144
メモリバケの要因は大量にあるので、ほんのさわりだけ。
念のために、俺はソフト屋でありハードウェアのことは門外漢なのであしからず。


隣接線上の影響とかではなく、純粋にメモリセルビットの故障なら、
0を書き込んでも1を書き込んでも、どっちでも0になるとか、
また逆に、
0を書き込んでも1を書き込んでも、どっちでも1になるとかいうことが考えられる。
この場合だけなら、0とFを交互に書き込んでも、5とAの場合と効率は同じ。

次に、隣接データ線が影響するような場合、
あるbitにread/writeしたものが、実は別のbitに対するread/writeに引きずられるとかいう場合
0とFでは見逃す可能性が大きくなる。
もちろん5とAでもそれは言えるが。

さらに、隣接データ線により多くの同じデータが流れる場合、
周りのデータに合わせたデータに化ける可能性もある。
この場合、00とかFFではより化けやすく、かつそれを発見できない。
5とAだと、0と1の量が等しいアクセスとなる。

ついでにもうひとつ。

アクセス時間が影響する場合も考えられる。
要するに、直前のアクセスのデータが消えずにそれが流れるような場合。
この場合、0x00とか0x55とかを連続してread/writeすると検出できない。
なので0x55と0xAAを交互にアクセスするのが良い。

データが保持できないっていうメモリ障害もありえるね。
書き込み後、リフレッシュ保持時間以上の間隔を空けてベリファイする。

>>145-146, >>148
あんまりに簡単に釣られすぎ。(w

n bit × 1 のメモリを並べたメモリモジュールなら、各々のメモリーにとっ
て見れば 0x00, 0xFF を書くのと 0x55, 0xAA を書くのは違いはないだろ。

それこそ、>>145-146 が言うように、２進数表記 (ビット単位) で考えれば明
らかだろ。偉そうに H/W のお勉強とか言ってると恥をかくぞ。

で、マルチビットメモリーなら 0x55, 0xAA が有利なのかい？

>>147
アドレス線について語ってるのは、>>140 だけ。
しかも、アドレス線ショートについて一般的なこと言ってるだけ。
まあ、>>136 がなに言ってるかわからんから無視されてもしょうがないわ
な。(w

>>149-150
まあ、そこまで言い出すときりがない。
そもそも、D-RAM はデータ読んだだけでそのデータが消えちゃうんだから、読
み出しだけでも他のセルに影響与えるからね。

全然分かってない奴がいるな

>>152
話についていけないなら、無理してついてこなくていいんだよ。。(w

とりあえず、高速に処理する方法から遠ざかっているよな

＞メモリテストなら、0を書き込むのはあまり意味が無い。

別にメモリのテストではなく、ある処理をしていて、磁気データやバーコードデータ
をある動きの中でゼロクリア＆確認したいだけです。

>>151
だからどういうエラーが考えられるのかは、
メモリとかのH/Wを勉強しないと分からないだろ？

>>155
マルチスレッドなら、そういう確認は意味がなく、排他制御を考えた方が良いよ。

>>151
配線によるエラーって、それこそチップ内部の配線で
特定のメモリセルブロックのみ断線とか混線とかしてる場合とか
コンデンサのチャージエラーとかグランドへの抜け（ショート）とかって話だよね？

もはや録音テープと化してるなw

>>151
お前、2進数だって説明で納得できるのか？
俺なら、0x00と0xffの場合とどう違うんだ？って思うぞ。
だからこそ、H/Wの勉強が必要なんじゃないのか？

H/W の勉強って言ってる奴は、馬鹿じゃないのか？
いったいどの分野を指してるんだ？

>>159
それは録音様がこのスレにも降臨なされたという意味ですか?

うん

>>161
遅レスだが、H/W診断プログラムを作成するのに
対象のH/Wを熟知してなきゃダメだろって思うんだが。

知らない奴に使わせて無茶苦茶しても壊れない・・・ってのは製品ではいいがナマハードではだめか

>>165
このポート、リード専用で、書くと物理的に壊れますから。とかなら経験あるなぁ。

ああ、そういうの俺も経験ある
というか、outbにラッパー入っててあるポートへの出力に
アサート入ってた

x++;
x=-!x;
ってどっちが速いの？＞＜

>>168
>x=-!x;
嫌がらせとしか思えない。

>>168
!じゃなくて~だろ。
x = -~x; と x++; をgccで試したら同じアセンブラ吐いたので、答えは同じ。

>>168
勿論x++;の方が速くタイプできるに決まっておろう。

てか、x++; じゃなくて ++x; を使うように習慣付けとけ。

>>172
なんで?

C++では前置と後置では意味が違ってくるから、C++を睨んで前置の習慣をつけるべき。
#だとは思うが、このスレでは別に指摘するほどのことじゃないと思う。

Cで++xよりx++が好まれるのは、x += 2とした場合と左右の位置が変わらないから
・・・な気がする

コンパイラやコンパイルオプションで変わる

ハッカーの楽しみ買いました。
毎日オナニーしています。

dst++ = src++;

こう書きたいからなぁ

>>173
http://www5.atwiki.jp/vc310ice/pages/4.html#id_1308a768

bcc32では
x++;の方が速かったです。

inc
と
not
neg
の違いでした。(-O2)

ビット演算を用いることによりブランチフリーにする意義は？

ストール避け

ストールってなんですか？
わかりません＞＜

>>183
寒い時に使う奴だよ。

CPUは1つの命令を実行するのに何段階かの行程を経る必要があるのです。

モダンなCPUには丁度ベルトコンベアで流れ作業するような感じで、命令の実行までの処理を順番に
流していくための機構が備えられています。これをパイプラインという
これにより、見た目上、１つのパイプラインで1命令1クロックで命令が実行されることになります。

ただ、すぐ次の命令の流れが前の命令の実行結果に依存してる場合、

・投機実行を備えてないプロセッサの場合、分岐先が確定するまで
　何を流せばわかりません。したがって、それだけ待たされることになります。

・分岐予測＆投機実行なんかが導入されてる場合（大抵のx86アーキはそう）でも、
　予測が外れた場合、投機してたステージを全部破棄して再度読み直すことになります。

10ステージのパイプラインなら10クロック＋αは、分岐（or投機失敗）のたびに、
命令実行が止まることになります。これがストール。

あーつまり エンスト は エンジンストール の略だ。

つまりストールマンは思考停止した人ってことくぁｗせｄｒｆｔｇｙふじこｌｐ；「’」

レジスタの値を0にするときなぜ以下のように書くのでしょうか？
xor eax, eax

速いから

C言語で書くとこれと等価なんだけど
a ^= a;

XOR演算の定義は

入力1 入力2 出力
　　0　　　0　　　0
　　0　　　1　　　1
　　1　　　0　　　1
　　1　　　1　　　0

だから、同じ値でビット排他論理和を取ると、レジスタの値によらず必ずゼロになる。
これは大概の実装ではレジスタに0をロードするより速い。

>>190
詳しい説明ありがとうございました。

>>185
わかりました＞＜

ストールによるデメリットと、投機実行的中のメリットで期待値はトントンにはならないんですか？

ブランチフリーのが正しい姿勢なのですか？

こんな質問をするなんてよく分かってない証拠ですね＞＜

よくよく考えると今の質問はナンセンスでした。
ようするにブランチフリーにすると
パイプライン達を相対的に酷使し続けられるってことですね＞＜

それから、おだんごいただきます。＞＜
っ-●○◎-

最近はXORで初期化するよりイミディエイトで0入れた方が速いらしいが

CPUによるよね。同じプログラムでもBCCとかはXORだけど
SHC（SHっていう日立製CPUのコンパイラ）だと0をセットしてるね。

っ-●-----
余ったのでお返しします＞＜

>>16
きめぇｗ

>>198
そんなトリップ付けた奴に言われたかないだろうな。

SHって基本的に命令が全部16ビット固定長のアレか。

XORとSUBはreg,regに限れば同じだよね？

8080の古より0クリアにはxorと伝承されてきたのです。
#いや、subはフラグに影響を与えるから避けたと言うのが真相だと思うけど。

xorもフラグに影響しますが。
じゃなくて、

フラグ(CY)に依存しないsub命令が8080/Z80には無かったから
XOR A でアキュームレータをゼロにするのが一般的だった。

本当に一番最初にXOR Aを見たときは、「こんなとこで何やってんだ」と思ったけどね。
XORの動作を確認して、初めて納得した。
だって、実際にXORを使う場面なんて、数値演算(暗号/画像等)以外では
ゼロクリア以外無いじゃん？
積極的に使ってあげないと。

んー、と思って書いてみたものの、ちゃんとZ80にもSUBはあるなあ。記憶違いだ。

離散数学って代数と関係あるの？

>>203

CRC とか パリティとかで

あ、それ数値演算？

っつーか SUB も AND も数値演算ちゃうんかと

論理演算

>>203
MSX2のスプライトで脚光をあびたな

比較って何命令かかりますか？
x>y
x==y
とか。

マシンサイクルのことか？

はい。
addとかより時間かかりますよねきっと

おなじ

えー、うちのマシンだと２時間くらいかかったぉ

一概には、ステート数は言えない。
それは、例えばC言語での記述のことだと思うが、
マシン語の対応が、x,yが何であるのかによって
命令数も変わってくるし、例えそれが純粋な比較命令
cmp EAX, [mem]
一つであったとしても実行時間は
すんなり行けば、1サイクル（なおP4だと、１サイクルで最大3命令同時実行できる）
で済むかも知れないが、命令の並びによって余分に掛かることもあるし
最悪ペナルティが発生すると数十サイクル掛かることもある。

ありがとうございました。

addとorはどちらが速いですか？

リファレンス嫁

ビット演算とかしたことない素人です。
ある数nを2進数表示して
　　n=u[0]+u[1]*2+u[2]*2^2+…
としたときのu[0〜N]を扱いたいんですが
どのようにしていいかわかりません。

もっと具体的に書くとある数aに対して
　　a^u[0],(a^u[1])^2,(a^u[2])^4,…
を求めたいのです。

わかりやすく教えていただけるとありがたいです。
よろしくお願いします。

for (int i = 0; i < N; ++i, n >>= 1) u[i] = n & 1;

リファレンスはどこで閲覧できますか？

チップベンダーのサイト

E・∇・ﾖﾉｼ　＜222ｹﾞｯﾄ♫

ちょっと前の話題だが、X86でゼロクリアにXOR使うのは速度面ではなく、
即値使うより命令サイズが小さくなるからじゃなかったっけ？

そう。
ただ、何故subじゃなくてxorなの？という話だった気がする。

論理回路の実験で半加算器・全加算器作ったことある奴ならわかると思うけど
ビット演算は原則的に同じビット同士で演算すればいいけど、算術演算は桁上げがあるから
回路の負担も大きいわけ。
実装によりSUBがXORより遅くなる可能性はあるが逆は原則としてないじゃん。

いずれにせよ、同じレジスタ同士のXOR演算はレジスタリネーミングのヒントを与える効果もあるし
（少なくともここ最近のIntel CPUの実装ではそう）積極的に使うべきである。

あと、速度が一緒でもXORのほうが消費電力・発熱が僅かに少ないなんて利点もあるかも。
・・・仮にそうだとしてもホントにどーでもいいレベルの差だろうけどｗ

>>225
同期回路ならまずそれはないな

ヒント：Pentium 4のレイテンシ・スループットを参照

別スレでも暴れてるようだが、本物のバカだな。
「x86でsubではなくxorが使われるようになった理由」にPen4を持ち出すとは。

まあxorは単独bitで演算できるのは事実だが
8086や80386でレイテンシやスループットに差があったのか
調べてから書き込んだ方が、バカをさらさないで済むと思うぞ。
#俺は調べる気はないから、本当に差がある可能性もあるけどな。

>>229
攻撃的な人ですね。
事実を証明できない、調べる気もないならそんな縦読みできない長文を赤い顔して書きなさんな。

自分以外の書き込みが全部同一人物に見えるのが、デムパの特徴。

8086は組み込み用途では現役です。まあ初期のものと実装変わってるかもしれないけど
http://www.intel.com/design/intarch/intel186/docs_186.htm
>>229は英語読めるようになってから出直してきてください

証明

x86が世に出て、コンパイラがゼロクリアに(x86の)xorを使うようになった時代に
Pentium4は有りませんでした。

証明終

ADD/SUBのほうがAND/OR/XORより速くなってたらXORじゃなくてSUB使うこと推奨してないし
ノイマン型コンピュータが発明されてから、論理回路の理論は殆ど何も変わってないのですよ。

で、マニュアルによると

ADD/SUB/ADC/SBB
reg/memory with register to either 3/10
immediate from register/memory 4/16
immediate from accumulator 3/4

AND/OR/XOR
reg/memory and register to either 3/10
immediate to register/memory 4/10
immediate to accumulator 3/4
だそうだ。

ftp://download.intel.com/design/intarch/manuals/27095003.pdf

どうみてもXORのが優勢です。本当にありがとうございました。


Pentium4を例として挙げたのは、16ビットのALUを2個束ねたものを動作クロックずつタイミングずらして
実行するものだから。スタガードALUっていうらしいけど。
暇だったらZ80のマニュアルも調べてみて。こいつも「8ビットCPU」だが内部は4bitニコイチ実装だったはず。

×XORじゃなくてSUB使うこと推奨してないし
●XORじゃなくてSUB使うこと推奨してるはずだし

なんかわからないけど
必死だね

・∀・）っ------- ◆Pu/ODYSSEY

↑コイツ同期回路の意味分かってねーな

大丈夫、暴れるコテに何言っても無駄だから。

よくわからんが、レジスタの中身でなく、メモリをゼロクリアする場合はどうなの？
直接ゼロ書き込むほうが速そうな気もするが・・・

XORだとメモリの内容を一度レジスタに入れて、さらにそれを他のレジスタにコピー
し、XORした結果（当然ゼロ）をメモリにいれることになるよね？

お馬鹿ですまん・・・

だんごさん無くなったので私怨満々な変な人刺しておきますね。
とりあえず、XORよりSUBでゼロクリアしたほうが速い処理系ってのは存在し得ないでしょ。

他の演算を見ても、仮に半分のビット数のALUを2回使って出力を得るような構成だったとしても、
同じ桁のみの演算で完結するならビット論理演算は繰上げ／繰下げを無視して実行できるから、
XORがSUBと同等かそれより少ないクロックで実行できることはどんな処理系

消費電流の観点から言ってもSUBを敢えて使う理由はない。
全加算器の実装だけど、入力がx, yとci(carry-in), 出力がsとco(carry-out)とすると

s = XOR(XOR(x, y), ci)
co = OR( OR( AND(x, y), AND(x, c0) ), AND(y, c0) )

まぁ基本的な素子もNANDもしくはNORの複数の組み合わせで扱われることが多いんだけど
全加算器でXOR2個分は少なくとも使うわけだから少なくとも必要なゲート数は圧倒的に加算のほうが多い。

引き算は2の補数に変換して1加えたものを足すから、1を最下位ビットの全加算器のcarry-inとして
扱っても、ビット反転＋足し算だから、これより更にNOTゲート1個分ずつ増える。


>>239両方の入力に同じレジスタから信号通すように回路を組めばいいでしょ。
レジスタの内容のコピーってなにげに時間かかるよ。

×2の補数に変換して
×1の補数に変換して

ここは理屈としてはこういうことなんだけど
-x == ~x + 1

クロックが上がれば上がるほど信号遅延の問題はシビアになってくるよ。
俺に噛み付いてる香具師は電子の移動速度が無限に延ばせるとでも思ってるわけじゃないでしょうけど。

移動速度の限界があるからこそ、Pen4の倍速ALUは32ビットではなく16ビット×2という構成をとらざるを得なかった。

なんつーか、そもそも根本から話の観点が間違っているのに自分の風呂敷広げる以外に何も見えなくなっている様が哀れ蚊のようだ。

xor使うのは、代入より早くてスマートだって感じで、あとフラグの動作とかで使ってただけだなあ。
subでもよい場面も数多くあっただろうけど、わざわざその場合だけsubにするのは逆に変だし
バグりそうな気がしてね。（あくまで気がするだけでこんなことで本気でバグるとは思ってない）
あと読む人だってxorの方が慣れてるだろうし。

今じゃ、別な意味でxor使うね。（暴れている人の意見に同意）
昔は、xorなんてループの外に出すものと決まってたけど
逆にループの中に入れて毎回実行させるほうが圧倒的に早い場面もあるし。

ここってプログラム板ですよね。
一応念のために聞きますが・・・

メモリをゼロクリアするとき、アセンブラがこんなん吐きました

ゼロを代入

MOV　　　　#0,　R1
MOV.L　　　R1,@R4

XOR

MOV.L　　@R4,　R6
MOV.L　　@R4,　R2
XOR　　　　 R2,　R6
MOV.L　　　R6,@R4

コンパイラはSHC（SHっていわれるCPU用のコンパイラ）です（ver9.0）

私怨で食って掛かって、論破されるとスレ違いだ云々わめく詭弁者って
どこにでもいるんだよね。

大学時代にとってた教養科目で、算術演算が整数加算しかない仮想
プロセッサで机上プログラミングをする内容の回があったんだが
引き算に補数をとって加算するのを地でやってた。

ネットで調べてみるに、どうやら昔の安いプロセッサって大抵
こういう実装だったらしい。
XOR使うって慣習はこの頃に確立されてたんじゃねーのかね。

算術演算がXOR演算を部分的に利用して実装している以上、XORそのものより
クロック数が多くなることはあっても少なくなることは絶対にないし、
むしろ高クロック化と多ビット化で桁上げの信号遅延が深刻になり、
再び乖離していくんじゃないかと思う。

だからたとえ今XORとSUBが同じクロックで実行できるとしても
ゼロクリアのXORをSUBに強いて置き換える真似はしない。

論理回路
AND, OR, NOT, NORとかで
XORとかSUBを実現させようと図を作成してみたら面白いよね。
一気にSUB使いたくなくなる。

>>248
こんなところで真面目に言っても意味ない
図に乗るな！って言って止めればよいだけ

正論だったとしても一言二言余計な事を書くから叩かれる訳で。

まぁ、68000なら0代入は論理差も算術差も使わないのが常道だったわけだが。

moveqか

なんか遠いところへ来た感じがするな・・・

まあ普通面と向かって話してたら、屁理屈言うな、って言われて終わるだけなのが
なぜか2chじゃ勝ちになるっていうわけ分からん不思議世界

>246
ごめん、SHってなに？

Super Hitoshi

勝ちになるってところが重要なポイントだな。
数多く揶揄して、何が何でも勝ち負けに持ち込むんだよな。

結局246は何が言いたいの？

zeroクリアはimmidiate代入よってことだろ。
MIPS系じゃ命令数もバイト数も増えないし、実行時間も変わらんし。

>>246
仕方あるめー、*R4 が必ず同じ値を読み出す保証なんてないから
*R4 ^= *R4; みたいなコード書いたらそのようなコード吐くわな。

>>252-253
MC68000 では clr.l dn より moveq #0,dn の方がなぜか速かったな。

よく判らんが、>>248 が論理回路に疎いのは解った。

まだ続くのか？
もうどうでもいいだろ
っていうか、どうでもいいっていうこと自体まさにどうでもいいや

ここにはいろんな知識人が隠れているのでワクワクします。

見るからに自演が多いな
２〜３人でやりあってるんだな

僕は外野ですよ

実際に xor reg, reg より sub reg ,reg が遅いCPUはあるの?

そもそも、ビット演算単独でスレ立てんな。
これならまだconstスレのほうが有意義だったぞ。

ビット演算の事を考えると私はこんなにも幸せになれるのです。

>>268
俺に聞けｽﾚで興奮した中学生が勃てた
ﾈﾀｽﾚですから。

ビット演算があればご飯３杯は食べれます

SQLにビット演算が無いのって使いにくいよね？

a

いつからこの板VIPクォリティ導入されたんだ？

糞コテが書くようになってから。

負け犬必死だな

なんだと！

　　　 ﾊ,,ﾊ　　ちぽちぽ　　　 　
　~(~(*‘ω‘)　　　　　　　　



　　　 ∧∧　　ちんぽぽちんぽぽ
　 　 (*‘ω‘)
　〜（,,,ι,J


　　　∧　∧
　　(*‘ω‘ *) 　ちんぽっぽ
　　　(　　　)
　　　　v v

ビット演算で使うのって言ったら
やっぱりフラグとトグルスイッチ

8要素のソート
static void bi_sort( int* a, int* b ) {
        int d = ( *a ^ *b ) & -( ((unsigned int)*b - *a) >> 31 );
        *a ^= d;
        *b ^= d;
}
#define BI(x,y) bi_sort( a+x, a+y );
void oct_sort( int* a ) {
        BI( 0, 1 ) BI( 2, 3 ) BI( 4, 5 ) BI( 6, 7 )
        BI( 0, 2 ) BI( 1, 3 ) BI( 4, 6 ) BI( 5, 7 )
        BI( 0, 4 ) BI( 3, 7 )

        BI( 1, 2 ) BI( 3, 4 ) BI( 5, 6 )
        BI( 1, 3 ) BI( 2, 4 )
        BI( 1, 5 ) BI( 4, 6 )

        BI( 2, 3 ) BI( 4, 5 )
        BI( 2, 4 ) BI( 3, 5 )

        BI( 3, 4 )
}

>>272
> SQLにビット演算が無いのって使いにくいよね？

非常におそレスだが、あるやつもあるぞ。
http://www.postgresql.jp/document/pg812doc/html/functions-bitstring.html

まあ、あったからと言って SQL が劇的に使い易くな
るとは思えないが。

>>281
SQLくらい高級な言語にビット演算があったところで、
高速化しそうな気もしないしな...
ディスク容量は節約できるかな？

>>280
書き忘れたけど、
「分岐なしソート・Pentium4ユーザにお勧め！」ってなとこです。

>>282
> SQLくらい高級な言語にビット演算があったところで、
> 高速化しそうな気もしないしな...

いや、その認識はおかしいと思うぞ。
SQL って一行プログラムみたいなもんだから、一つの演算
子の高速化でも結構影響度は高いよ。
なんと言っても、その一行が 10万件とかのデータを処理し
たりするかもしれないからね。
ビット演算子がないがためにいろいろ苦労してやるよりも、
データベースエンジンの最適化も効き易いだろうし。

SQLでビット演算が必要なケース・・・マジわからん。mod演算とかで済むんじゃないの？
掛け算・割り算より数クロック早いとかよりもSQLの構文解析のほうがよっぽどクロック数は食うと思う。

SQL文は極力単純にしてデータの加工は極力ローカルでやるってのが高速化の鍵だと思う。
ああ、必要ないデータまで取ってこないってのも大事だけど。


>>282
ヲレならPentium4限定ならSSEx使うと思う。
4byte値なら一度に4つずつ扱えるしね。

>>284
> mod演算とかで済むんじゃないの？

言ってることが、マジわからん。

> SQLの構文解析のほうがよっぽどクロック数は食うと思う。

お前、でかい DB 使ったことないだろ。

>>285
あるわけねーじゃん。

Pu/ODYSSEYこのキチガイ触るべからず

今日の団子はここで暴れるのかw

>>282
そうなんだけど、そうやってSSEを効率的に使うためには、
やはり分岐の無い処理ってのが必要な訳さ。

>>285
ビット演算がmod演算で置き換えられる(?)理由は俺もよくわからんが、
ビット演算が必要な理由もまた良く分からん。
つか、最近のDBMSはSQLをネイティブコードにコンパイルするのでしょうか？
だったらOK、ビット演算したくなる気持ち、
びんびん伝わってくるぜ！

>>282
あ、じゃなくて、もしかしてSSEには
撹拌命令とかがあるから、それを使えばいいってこと？
なるほどねー。

>>286-288
安置乙ｗｗｗｗ

>>289
最近の DB は IP アドレス型とか MAC アドレス型と
か持ってたりするから、ビット演算ぐらいできないと駄
目でしょ。

それより、「ネイティブコードコンパイルされるなら、
ビット演算したくなる」の方がよくわからんのだが…。

>>290
正解。NetBurstはロード・ストアをDQWORD単位で行わないと効率が悪いアーキテクチャだからね。
シャッフルうまく使えばL/S回数も減らせてウマーなわけです
イミディエイトの値が決めうちだからAltiVecみたいにはいかないのが難点だけど。
あとmax/minの判定するそのものズバリなインストラクション用意されてるし。

>>292
そういうことか。でもどうせサブネットマスクの生成とかっしょ。構文あるじゃん。
OracleやDB2やらにやらす必要あるわけ？
まさかDB使ってDNSやNAT、ARP/RARPのサービスの再発明しようとしてるわけじゃないよな？

パイプラインを詰まらせるシャッフルが新しいボトルネックになって
ストールしまくりで全然解決しない気がするんだが。

アンパック（インタリーブ）命令でもできるかも・・・ちと叩き台のコード書いてみるか。
コンパイルオプションでCMOV使うようにすればいいだけ、という考え方もできる。

今使ってるマシンPentium Mなんだよな。NetBurstシミュレータって無い？

Pen4のSIMDはかなり並列実行に強いから
直列処理じゃなくて何個かソートを並列して実行できれば
いい感じになるんじゃないかな。

あぁ痛いコテが常駐している・・・

こういうのを本当に除外したけりゃ全員で完全無視すりゃいい

>>283
ビット演算の有無による効率を考える前に
物理的にひとつの値に論理的に複数の意味を付加しようとする
頭のおかしい設計者を排斥した方がいいと思うが。

クロック単位で云々ぬかす莫迦もどうにか排斥できないものかね。

ビビっと来た！

>物理的にひとつの値
>物理的にひとつの値
>物理的にひとつの値
>物理的にひとつの値
>物理的にひとつの値
>物理的にひとつの値
>物理的にひとつの値

空気を読まずに>>280のAltiVecバージョン。元のコードの片鱗も無いけど。
あー、16byte境界にあわせてあること前提ね。

#include <altivec.h>
void vQuickSort(int e[8]) {
register vector int v1, v2, v3, v4;
v1 = *((vector int)&e[0]); // lvx
v2 = *((vector int)&e[4]); // lvx
v3 = vec_max(v1, v2); // vmaxsw
v4 = vec_min(v1, v2); // vmaxsw
v1 = vec_mergeh(v3, v4); // vmrghw
v2 = vec_mergel(v3, v4); // vmrglw
v3 = vec_max(v1, v2); // vmaxsw
v4 = vec_min(v1, v2); // vmaxsw
v1 = vec_mergeh(v3, v4); // vmrghw
v2 = vec_mergel(v3, v4); // vmrglw
v3 = vec_max(v1, v2); // vmaxsw
v4 = vec_min(v1, v2); // vmaxsw
v1 = vec_mergeh(v3, v4); // vmrghw
v2 = vec_mergel(v3, v4); // vmrglw
*((vector int)&e[0]) = v1; // stvx
*((vector int)&e[4]) = v2; // stvx
}

たった16オペレーションで済む。ちなみに8bit×32要素なら24オペレーション。
ただ、依存関係があるから並列実行性能はそんなに良くない。
VSIUとVPERMはMPC7400/7450, PPC970いずれでも並列動作可能だが
このコードの場合どこにも並列化可能なところがない。
ただし要素数がもっと増えれば、たとえば4byte×16とかなら並列化は有効。

あと、こいつのSSExへの応用だけど、ｘ86の演算はSSExも含めて全て破壊的だから
max/minをとるたび、インタリーブするたびにレジスタの値をコピーする必要がある。
しかし、Pentium4レジスタ間のmovq/movdqaのレイテンシが異常にデカイから困る。
まあPentiumMとかMeromあたりではあんま関係ないだろうけど。

なお、IntelのSIMDクラスライブラリには vec_merge{h,l} に対応する unpack_highと
unpack_lowがあるから、ただコードを移植するだけならかなり簡単。

ここだけ訂正しとく

- v1 = *((vector int)&e[0]); // lvx
- v2 = *((vector int)&e[4]); // lvx
+ v1 = *((vector int*)&e[0]); // lvx
+ v2 = *((vector int*)&e[4]); // lvx

- *((vector int)&e[0]) = v1; // stvx
- *((vector int)&e[4]) = v2; // stvx
+ *((vector int*)&e[0]) = v1; // stvx
+ *((vector int*)&e[4]) = v2; // stvx

Cで考えれば結構簡潔に見えるけど2オペランドベースでレジスタが少ないことを
前提としたロジックって考えるの結構大変だと思う。
特にターゲットがPentium 4みたいな変態マイクロアーキテクチャだと特に
movやpush,pop命令吐きまくりでちっとも早くならないなんてことは結構ある。

所詮はCなんかも3オペランド命令ベースでレジスタが豊富な命令セットアーキテクチャ
向けの言語ってことね。

＞所詮はCなんかも3オペランド命令ベースでレジスタが豊富な命令セットアーキテクチャ
＞向けの言語ってことね。

( ﾟдﾟ)ﾎﾟｶｰﾝ

>>302
(1) v1とv2の要素を一個ずつ比較して、大きいのをv3に、小さいのをv4に入れる
(2) v3の前２個とv4の前２個ずつをv1に、v3とv4の後２個ずつをv2にいれる

これを３回繰り返すだけで8要素のソートになるのかー。
面白いなAltiVec。漏れもマカーなので試してみようっと。

何を今更。
知ってる？GCCってレジスタが大量にある3オペランド演算ベースの仮想マシン向けにコード生成して
それから各CPU向けに帳尻合わせするのよ。
PowerPCなんかはまともなのにx86向け最適化がウンコなのってそのせいよん。

言語仕様として i++ とかもってる言語に...

＞所詮はCなんかも3オペランド命令ベースでレジスタ
＞が豊富な命令セットアーキテクチャ向けの言語って
＞ことね。

ねぇ...。アセンブラ以外に、Ｃ言語より RISC 向き
の言語を教えて欲しいものだ。

副作用が発生しない3オペランド。
レジスタ数が多ければソースを破棄しても痛くはない。
当然自由度が高くなる。

下らん事をいまさら自慢げに書かれてもなぁ・・・

真にC言語向きなのはアドレッシングモードが豊富なCICS。と書いてみるテス(ry

CICS CISC orz

>>309
68000系は、なんかアドレッシングモードがCに最適化してあったとか、
聞いたことがあります。

>>307
それでx86向けの最適化だと、Intelのコンパイラに遅れをとるのね。

>>309
まあ、そのくだらないことも、
書いてくれないと、漏れとか知らない訳だし。

そもそもここ、厨房向けっぽいらしいし。

>>306
やってることは、1位から最下位まで全部順位の出るトーナメント戦です。
人数がn人なら一人当たりlog(n)/log(2)回対戦すればいいことになります。今回は8人だから3回対戦すればいい。
最終的な並びはvec_perm(vperm)使ってやればもう好きなようにやってヨシ。

>>309
だってMMX/SSEって痛い仕様なんだもの。
pandnってあるじゃん。 a = ~a & b
マスク破壊されるじゃん。なんで a = a & ~b じゃないの。みたいな。
Appleのデベロッパー向けサイトでもその点について言及してたが。


今回問題になる点は
　「値を破壊される前に退避してください。あ、Pentium 4ではmovqもmovdqaもレイテンシ大きいからね」

どないせいっちゅうねん。まぁだから整数演算はPentium Mに負けるんだろうけど。
unpack high( or low)オペレーションって対として使うケースのほうが多いと思うんだけど。
このへんだけでも3オペにしてくれれば良かったのにさ。

で、オレみたいにAltiVecを使いたいがためだけにIntel移行発表後にPPC版Macを買う厨房もいるわけだ。

あ、ごめん。。。これ欠陥があった。
最初の比較で1番目に大きいものと2番目に大きいものが比較されたら・・・。

正確に出るのは最上位と最下位だけか。

＞だってMMX/SSEって痛い仕様なんだもの。
＞pandnってあるじゃん。 a = ~a & b
＞マスク破壊されるじゃん。なんで a = a & ~b じゃないの。みたいな。

どっちが楽か考えれば理由はわかる。
マスク値を保持するにはコピーするか2回notするしかないからね。

＞このへんだけでも3オペにしてくれれば良かったのにさ。

Instruction Formatを見てどうすればいいか考えてみてくれよ。
これ以上デコーダを複雑にならないようにできるならな・・・

うーん
デコーダだけの問題だとすればなら、パイプラインから分離されてる
NetBurstアーキテクチャならx86のコード体系とはかなり違うSIMD拡張
命令フォーマットってサポート可能だったんじゃないの？
まぁIntelも従来型CRISC殺す気も無かったんだろうな。
NetBurstを継続しAMDに嫌がらせするには絶好の拡張方法に違いない。
まあ消えるけど。

だ・か・ら、Instruction Formatを見てどこに追加のレジスタ情報を埋めればいいか自分で考えてみろって。

わたすは脳内CPUアーキテクトじゃないので、「既存のものを使う」としか答えません。
まぁ一般に普及してればの話ですがx86互換CPU（と言っていいのか？）では
Itaniumが理想です。

>>316
opcode・src1, src2, destでもopcode・dest・src1・src2でも
何か不都合でも？
困難なのは知ってますが、互換ベンダが実装が困難なもの作ったほうが優位でしょ。

レジスタ間move命令のレイテンシが十分に短くて命令帯域に余裕があるなら
既存のものでも十分だとは思ってはいるけど、NetBurstはどっちも×だから。
まぁ半年後には死ぬアーキテクチャについて語る未来はないし
不毛なことは考えませんよ。
ただ、AltiVecからSSEへの移植は苦労するだろうなって話。

MMX,SSEだけはModR/MやSIBの意味を変えろと言っているのか？

汚いx86がさらに汚くなってうんざりだな。

消えてるから何が起こってるか分からないけど
消えっぷりが半端で無いので笑える
ファビョって連レス乙

あぼ〜んせずに観察するのも
それもまた由

>>319
消えるアーキだからもうどうしようもないけど、せっかく分厚いデコード層で
仮想化してるんだから、この際それくらいやって欲しかったけどねー。
もしくはデコード無しでダイレクトにトレースキャッシュにμOPsをロードする
命令をサポートするとか。これならx86の命令セット自体は汚れない。

ま、こんなことやっても盲腸がまた増えるだけ、ってのはわかってるけど。

お題：地味で出番の少ないpmovmskbの有効活用法について
void Transpose8x8(BYTE a[8], BYTE b[8]) {
_asm { //8x8のビット配列の転置, 最適化あんまやってない
movq mm0, mmword ptr [a]
pmovmskb eax, mm0
mov byte ptr [b+7], al
paddb mm0, mm0
pmovmskb eax, mm0
mov byte ptr [b+6], al
paddb mm0, mm0
pmovmskb eax, mm0
mov byte ptr [b+5], al
paddb mm0, mm0
pmovmskb eax, mm0
mov byte ptr [b+4], al
paddb mm0, mm0
pmovmskb eax, mm0
mov byte ptr [b+3], al
paddb mm0, mm0
pmovmskb eax, mm0
mov byte ptr [b+2], al
paddb mm0, mm0
pmovmskb eax, mm0
mov byte ptr [b+1], al
paddb mm0, mm0
pmovmskb eax, mm0
mov byte ptr [b], al
emms
}}

VC++7.1の_MM_TRANSPOSE4_PSが酷過ぎる件について。

姉さん、 pcmpeq* mmX mmX で任意のレジスタの全ビットを立てる
組み込み関数が無いのは何かの嫌がらせです。

もっとも、 a = _m_paddd(a, a); で生成されるコードのアホさ加減を見れば、
VC++のレジスタカラーリングなんて全くあてにしたくないわけで。

>>322
＞消えるアーキだからもうどうしようもないけど、せっかく分厚いデコード層で
＞仮想化してるんだから、この際それくらいやって欲しかったけどねー。

そういう問題じゃないって言っているだろ。
x64も同じ問題を持っている。ビット演算スレなんだから命令とオペランドの
ビットパターンを見てから発言すれば？

pandn命令を2オペランドでやるとすればデータとマスクどちらを破壊するのが
良いかはマスク破壊が正しいのでは？大量のデータを処理する際にスループットは
どうにもできないけどレイテンシは投機的な処理で隠蔽できます。では、一般的に
マスクとデータのどちらが投機的にロードし易いか？
内部のロジックだけでなく用途を考えても答えはでますよね。

所要クロックスレの1の方がマシだな。

キチガイ出没記念ｶｷｺ

ん？ >>327 が キチガイ？

>>326
反転するほうが保持したいデータだった場合は？そんなの場合によるだろ。
第1オペランドに入れる値のほうは明示的にレジスタにロードしないといけない。
しかもそれを破壊しないといけない。

おいら的問題は、
・NOT(全ビット反転)を取るのが1命令でできない
・替わりにあるpandnが異常に使い勝手が悪い

まぁ正確に言えば両方サポートして欲しい。
あと、pornとかpnorとかも欲しいかな。NORなら単独でNOT演算ができる。


で、MMX/SSEでビット反転の手段
pcmpeqでレジスタ1個潰して全ビット立ててpxor
もしくは全ビット立ったQWORD/DQWORD値をメモリに持っておいて
pandn（Intelのラッパー関数はこーやってるようだ）、あるいはpxor

見事に >>1 の通りのｽﾚになってよかったな。

pandn,por,pxorで十分と思わない奴は。。。

>>326
＞マスクとデータのどちらが投機的にロードし易いか？

データはどっちにしろロードするわけで・・・
両方ロードするのと、データだけロードするのとどっちが良いかという話では？

まめめ

お団子の匂いがしたのでよってきますた。

団子さんって博識ですね。
団子さんみたいになるには、何を勉強すればいいのでしょうか？

ひ・み・つ♪

おい団子
お前はHONDA車に乗ってる事はおみとおしだ。

>>336
トリがいつもと違う様な・・・

PAJERO大好き

>>336
そんなこと言わないで教えてください＞＜

おい団子！新ネタ投下汁

>>341
団子汁

過疎ったな

まだ変なコテいたんだ。
色んなスレを荒らしまわってるデムパ乙。
自分を攻撃してくるやつは全て同一人物だと思ってしまうかわいそうな子。

ネタも用意しないで噛み付くのが目的ならスレに不要と思われるけど。どっちが荒らしか自覚したほうがいいｗ

>>341
SSEのmaskmovq, pextrw, pinsrwの活用法について考える、とか。画像処理以外で。
こいつは巧いと思った。
http://www.dawgsdk.org/tripmona/index.php/optimization

xor 団子, 団子

＞∀＜）っ-○●◎- ◆Pu/ODYSSEY >> 64

シフトではみ出た桁は0になる

>>348
IA-32だと何も変わらないがなｗ

>>345
>どっちが荒らしか
そりゃあ、糞ｺﾃの方に決まっている。内容を読むまでもない。

仲良くしてやって＞＜

保護者なら保護者らしく糞は引き取れ

保護者ではないです＞＜

うんこうんこうんこー

晒しage

固定長命令と可変長命令のメリット、デメリットを教えてください

まず自分で考えてからな。

>>356
基本情報の教科書でも読んでろ
商業高校にでも行って

>>356
学部１年レベルな．
ttp://www.amazon.co.jp/exec/obidos/ASIN/4274131912/249-8278027-6955557

ten byteがサポートされているのはインテルのみ？

>>356
・柔軟
・速い

保護者出てこいヴォケ
とうとう自作板にまでしゃしゃり出て来るようになったぞ
怒

悪い子じゃないんです。
学位だって持ってるんです。
ちょっとあおり耐性が足りなかっただけなんです。
仲良くしてあげて＞＜

>>362
どこ？

ヒント　半可通は半可通を呼ぶ

ここに潜伏してる人達はだんごを余裕でねじふせられる程の猛者揃いですか？

ねじ伏せるという発想が既に嵌っているまさに泥沼首まで・・・！

つーかキチガイと張り合うのはキチガイだけ。相手にしないといい

ねじ伏せるも何も間違い指摘スルーじゃ話にならん。

団子は間違いを犯しますか？

俺の団子は時々間違いを犯します

時々俺は間違って団子を犯します

時々犯しますは俺に団子を間違います

意味がわからんので構文木も書いてくれ。

そろそろ話題をシフト
このスレ = このスレ >> 374;

厨房くさいトリッキーな高速化テクニックを集めてみませんか？

>>375
団子が来ますよ？

1ビットだけ立ってる整数の、どのビットが立ってるのか調べる方法ありますかねえ。
例えば16→4、 128→7、 1→0を返す様な。

1引いてループ分岐なしビットカウント、でもいいのだけど
「1ビットしか立っていない」って条件を生かすと
もっと少ない手間で出来そうな気がする。

>>377
>もっと少ない手間で出来そうな気がする。

表引き。

ハード依存だが浮動小数に変換してメモリに保存→整数で指数部を読み出し

>>378
表引きなら何ビット立ってようが同じ希ガス

>>377

x86なら bsf/bsr で十分速い
と書くと団子が能書き垂れ始めます

ていうか逆にビット位置を保持してそれからビットを作れよ

>>376
来ますたよ？
あーあ

>>377
やってることはlog(x,2)の簡単化
素直にbsr でいいんじゃない?

> nをスキップする0の数として、だいたい11+2*nクロックサイクルかかる。

（ ´,_ゝ｀）ﾌﾟｯ

"\0\0\1\32\2\27\33\0\3\20\30\36\34\13\0\15\4\7\21\0\31"
"\26\37\17\35\12\14\6\0\25\16\11\5\24\10\23\22"[i%37u];

ジョークで書いてみたものの除算が入るから遅いだろうなぁ

BSF or BSR

uint8 table = {
32, 0, 1,12, 2, 6, 0,13, 3, 0, 7, 0, 0, 0, 0,14,
10, 4, 0, 0, 8, 0, 0,25, 0, 0, 0, 0, 0,21,27,15,
31,11, 5, 0, 0, 0, 0, 0, 9, 0, 0,24, 0, 0,20,26,
30, 0, 0, 0, 0,23, 0,19, 29, 0,22,18,28,17,16, 0
};
table[ (i*0x0450FBAF) >> 26];

クォリティ低いスレだな。

uint8 table[] {
ほげほげ
};

Rubyでテストして変換し損ねたｗｗｗ

>>387
あー定数の除算は乗算+シフトに置き換えれたんだったなー
結構面倒だったでしょ。お疲れさんｗ

マジックナンバーを自動計算するスクリプト組んでSIMDとかこの手の最適化に活用してる。

で？
それ速いの？

試せよ。


毒吐こうかと思ったけどやっぱり辞めた。x86じゃなかったらどういうコード書く気だかそっちのほうが気になるわ。

答えは>>383で出ているわけだが

x86じゃなかったら

ビットカウントのアルゴリズムを把握してる人間がそもそも誰でもわかるようなx86依存の専用命令を
答えられて納得するとでも思うのかな？テラクォリティ低す

>>381の言う通りでﾍﾟﾀﾜﾛｼｭｗｗｗｗ

CPU依存の一命令がないとまともにアルゴリズムを組めない人なのですか？>>381は。

このスレが大好きです

偉そうに能書きたれている誰かさんのコードも環境依存があるしな。www

もはや一つのｼｮｳだなこのやりとりは

あらゆる環境で動かないと意味が無い

ポータビリティなんか考えてる奴はバカ。
別の環境で動かしたいなら
その時に変換すりゃいいだろ

複数の環境をターゲットにしてる人もいる
人それぞれいろんな状況があるんだよ

自慢のロジックでもテーブル参照ですかw

>>402はx86以外なら一個一個ループを回していくらしい

>>402
逆だろ。
あらゆる環境で動くものを用意しておいて、ハード依存の高速化手法があればそれを適用すればいい。
ハードありきな回答しか出せないのを居直る時点で駄目駄目。

(読まずに脊髄レスしたのは内緒だ....)

あらゆる環境で動くコードとは
あらゆる「ハードありき」のコードの寄せ集めだろ。

試しにあらゆる環境で動作する
ハードに依存しないコードとやらを書いてみろよ

逆に、ためしにSHやPOWERにBSRを移植してみてくれよ。

68kやAlphaのBSRはどうみても別物です。
本当にありがとうございました。

Cで書けば移植性ほとんど困らないじゃん。
コンパイラが四則演算・ビット論理演算・ビットシフト演算、諸々を
ネイティブコードに置き換えてくれることを保障してくれる。
馬鹿だね。

要するにどこでネイティブコードに変換するかって話で
Cコンパイラはコンパイル時にそれをやってるだけの事
馬鹿も糞もねーよ。
ハードが隠蔽された高級言語こそが偉いと言うなら
c++.netでもjavaでもスクリプト言語でもなんでもいいからどっかいっとけ

つか、専用命令がなくても使えるジェネリックなビットスキャンアルゴリズムを聞いてるのに
「○○には組み込みの命令が用意されてるからそれを使え」じゃ全く話にならないと思うが。
逆に使えなかったら>>405みたいな解決法なんだろ。くだらねー。

>>411
>>409

レギュレーションが各自の脳内にあるから荒れるのは仕方が無い。

有名なビットカウントアルゴリズムだけど

int numofbits5(long bits) {
　bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
　bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
　bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
　bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
　return (bits & 0x0000ffff) + (bits >>16 & 0x0000ffff);
}

これは？

>>414
散々既出な上に、立ってるビットの数は1個と決まってるので話題違い。



とりあえずPentium 4で確認したがBSF/BSRは「遅い」。
Northwoodでレイテンシ-スループットは8-4, Prescottで16-2。
わざわざ移植性を犠牲にしてまで利用する価値があるかは、疑問。

掛算とシフトとロードは並列動作可能なので何個か同時処理すれば>>387のが
速いかもしれんね。

定数との剰余（or掛け算＋シフト）を使って一意なダイジェストを得るのは
かなりうまい方法だな。1バイトずつ分割してテーブル参照すると遅いし。

ただ、SIMDじゃ基本的にテーブル参照は使えないんで、論理・算術演算のみ
を使ったいい方法があればと思う。
AltiVecで16bit程度までならAltiVecレジスタ上にテーブルを展開できそうだから、
>>387的な手法＋vpermで写像をとって解決できるのだが。

>>414
その素朴な方法だと無駄が多い。
最低でもこれくらいにしなきゃ

int numofbits5(unsigned long bits) { 
    bits -= bits >> 1 & 0x55555555;
    bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333); 
    bits = (bits + (bits >> 4)) & 0x0f0f0f0f; 
    bits += bits >> 8;
    bits += bits >> 16; 
    return bits &0xFF; 
}

ただ、テーブル使う方が俺は好みだけどな

名無し乙

コンパイラの最適化に依存しそうだがこれでよくね？

c = (0xFFFF < n) * 16
n = n >> 16 | n & 0xFFFF;
c += (0xFF < n) * 8;
n = n >> 8 | n & 0xFF;
c += (0xF < n) * 4;
n = n >> 4 | n & 0xF;
c += (0x3 < n) * 2;
n = n >> 2 | n & 0x3;
c += n - 1;

static inline unsigned count(unsigned long bits)
{
bits -= bits >> 1 & 0x55555555;
unsigned tmp = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
tmp += tmp >> 4;
tmp &= 0x0f0f0f0f;
tmp += tmp >> 8;
tmp += tmp >> 16;
return (unsigned char) tmp;
}
static inline unsigned count(unsigned short bits)
{
bits -= bits >> 1 & 0x5555;
unsigned tmp = (bits & 0x3333) + (bits >> 2 & 0x3333);
tmp += tmp >> 4;
tmp &= 0x0f0f;
tmp += tmp >> 8;
return (unsigned char) tmp;
}

まる一日考えたが、１引いてビット数え上げするより速い方法は思いつかん
分岐・テーブル不要で32bit数をlog_2に折り畳むには、最低限５回の加算は必要な気がする

いっそジャンプテーブルで分岐させる

ビット1個しか勃ってねーんだからこれでいいじゃん。
依存関係が無いからSIMDでもVLIWでもこれでスケジューリング楽々。

!(0x0000FFFF & n) * 16 + !(0x00FF00FF & n) * 8 + !(0x0F0F0F0F & n) * 4
+ !(0x33333333 & n) * 2 + !(0x55555555 & n) ;

>>422
x86向けだけど、コンパイルしたらこんなコードになった
and edx,0xFFFF ;　cmp edx,1 ;　sbb ecx,ecx ;　neg ecx ;　shl ecx,4 ;　後略
でも、gccだとどうオプションつけても分岐ができちゃった

速度が気になるならハード依存のコードを書けばいいし
そうでないなら分岐使いまくりスタック操作しまくりの糞コードでいい。
糞コードでもいいならば単純な置換でいいんだし
別のハードで動かす場合に速度が必要になった時にだけそのハード専用のコードを書けばいい。
つまるところハード依存を気にせず良いと思ったコードを書くのが一番だ。

ごめんよ。たぶんスレ間違った

>>425
どうみても誤爆に見えないぐらいスレに沿ってるｗ

じゃあ合ってた

団子がどこにでもいるから一瞬どこに書いたのかわからん

RISCだと命令セットが単純だから、どのハードでも最速コードが同じになることが多い
ハッカーズ・ディライトもそういう前提で書かれてたんじゃなかったかな？
標準コンパイラのgccで団子鬼門の分岐ができちゃうんじゃ使えない気がする

gccだと-march=pentiumproとかで分岐はなくなった

>>423
コンパイラによってはひょっとしたらこっちのほうが効率いいかも。
(0x0000FFFF & n ? 0 : 16) + (0x00FF00FF & n ? 0 : 8) + (0x0F0F0F0F & n ? 0 : 4)
+ (0x33333333 & n ? 0 : 2) + (0x55555555 & n ? 0 : 1);

>>422は単に「こうやったらleaを吐くんだろーな」とか思って書いたもので
これが最速という確証とかも無し。
むしろテーブル参照のほうが速いでしょ。

-(expr)>>31とかやってやれば確実に0か1を取り出せるし、更にnegをとれば全ビット1か0に。
まあコンパイラの最適化性能を最大限生かしたいタチなのでこういうコードにしたけど、
ショボければショボイコードができることを意味する。まあ工夫は各自で。

>>429
x86ではsbbかcmov*を使ってくれること前提で書いた。
最適化無しの状態だとVC++でもヤバいコード吐くね。

GCCの最適化は安定しないので基本的にあてにしない。




HDの和訳本無くしたかも。文庫サイズなんで持ち歩きに便利だから買ってたけど＞＜
まぁ原著(わざわざAmazon経由で海外から取り寄せで購入)は家においてるんで支障ないが。

オマイら、ありがとう。
たすかったよ。

おｋ

XORを使うとテンポラリ領域なしで値交換できると聞きました。
本当でしょうか？

本当です。

詳しく教授してください

お前は現行スレ内を検索することも出来ないのかと
あと氏ね

ビット演算における偉い演算ランキングは
xor, and, not, 論理右シフト, or, 左シフト, 算術右シフトで異論はないね？

>>436
放置した方がいいよ

ローテートが抜けている。

団子ﾏﾀﾞｰ？

>>433
できるけど、今時のCPUだと却ってお荷物な方策だよ。

今の時代ビット演算の需要は
べらぼうに速いフラグ判定くらいじゃね？
のみ、いずれか、等価あたりはifでやるより個人的には簡単だし

>>440
ぷえ乙

フラグ判定以外にも需要ありまくりだろう
例えばビット演算全く使わないと
映像音関係ぜんぶウンコになると思う。

>>437
nand, norは万能

ビット演算を使わない人間は住んでる世界がそれで十分か
損をしてるかのどちらか。とはいえxorでの交換はお勧め
できない

メモリの中で低位アドレスからみて最初にビットの立ってる位置(アドレス，ビット番号)を
最速で検索するのはどうすればいいですか？

アドレスは、ループで地道に探せ。
ビット位置は、見つけた数をaとするなら
(a and (a - 1)) xor a
で最下位ビットを得ろ。
ビット位置を得る具体的な方法は、このスレ内を検索しろ。
お団子が色々提案してる

xorでの交換は、指定したビット位置だけ交換出来るのがメリット

これを組み合わせて、ビット単位に前回と比べて変化があったビットだけ採用するような事が簡単に出来る

団子ﾏﾀﾞｰ？

うはｗｗｗｗ
ＪＰＥＧでバイト飽和演算つかいまくりんぐｗｗｗｗ

団子は提案してるだけで試してないから駄目

なんだと＞＜

いまx64環境使えるんだけどなんか試してほしいものある？

>>453
試しに回線切って首吊ってみてくれ。

>>454
それだと結果が得られないからどうせなら実況中継してもらったほうがよくはないか?

>>454 だが断る＞＜

>>455 それなんてエロゲ？

って言いたいだけちゃうんかこの45歳

なにその俺のほぼ倍の年齢＞＜

Ω<ﾅｯﾅﾝﾀﾞｯﾃｰ

>>458
俺と同じか少し下くらいだったのか。意外。

学生かよ

ルーキーだ＞＜
1982年生舐めんなよ＞＜

>>462
工エｴェｪ（´д｀）ｪェｴエ工工

俺はタメか一個下からビット演算についていろいろ教わってたのか…

ドカタの俺に院卒のSEはいろいろ教えを請いに来るよ
相手が詳しければ年上、年下なんてどうだっていいこと

>>465同意。

まあ、小学生とかだとショックだけどな。
20いってりゃ特定分野の知識は年令関係ないでしょ。

登大遊はすげーと思うよ＞＜
学生ニートやってたときに彼の本にずいぶんお世話になった（彼は当時高校生

＞学生ニート

頭痛が痛くない

おい、団子はハッカーの楽しみの内容の何割りを理解できてるんだ？

>>465
知識範囲が狭い事は判明しているので20代は納得。

>>468
定数テーブル参照を1ビットマシンでビット演算だけで実現するくらいかな。





逆に30代以上なんて退役じゃんｗｗｗ
脳みその老化には逆らえんだろ

でも２ちゃんねらーって統計によれば30〜40台が一番多いらしいね。道理でリアルニートが（ｒｙ

>>465
つーか、30代以降なら見識を疑う。

>>471
＞学生ニート
要は、「引き篭もり学生」か?

流行りの言葉使ってみたくなる年頃なんだろ

ネット初心者ってそういうの好きだからね

30代が釣れたｗｗｗｗ

>>476の人気に嫉妬

40代かもしれんのに「釣れた」ってwww

>>449
>xorでの交換は、指定したビット位置だけ交換出来るのがメリット
>これを組み合わせて、ビット単位に前回と比べて変化があったビットだけ採用するような事が簡単に出来る

「指定したビット位置だけ交換」を組み合わせて
前回と比べて変化があったビットだけを採用する...
ようなことを簡単にやるにはどうすれば良いのだろう。

おしえてくだちい

>>479
このばあいの　「これ」　はタイトルの　ビット演算の事だろう

ビット演算だけでどこまでプログラムって作れるの？
あえて限界に挑戦した、みたいなサイトありませんか？

>>481
FAとかで使うシーケンサは普通にAND,OR,NOTだけ(ラダー)でプログラミングしますがなにか？

XORも出世したもんだな。
http://www.xbox-news.com/

>>482
どうやって？どうやって？

なぜぐぐらないんだ？
http://www.nagoya.melco.co.jp/fair/fa_basic/02/21.htm

>>484
ちょっと語弊があるかも知れないけどわかりやすく簡単に説明すると
シーケンサで扱うデータは(例外もあるけど)基本的に全部ブール値なのよ。
センサーやらボタンやらの入力もブール値(On/Off)だし、
シリンダーやコンベアを動かす出力もブール値(On/Off)。
で、制御はそれらの入力をAND,OR,NOTで加工したブール値を出力とすることで行うわけ。
実際のラダーのコードは↓こんな感じになります。

│　A　　　 C 　　　　　　　　　　　　　　　　　　　　D │
├┤├┬┤├─────────────○┤
│　B　│　　　　　　　　　　　　　　　　　　　　　　　　│
├┤├┘　　　　　　　　　　　　　　　　　　　　　　　　│
│　　　　　　　　　　　　　　　　　　　　　　　 　　　　　│

これで D = (A | B) & C; てな意味になります。

TextSS　のWindowsXP(Professional)64bit化おながいします

もしくは64bitにネイティブ対応したテキスト置換ソフトありますか？

>>487
おまえあっちこっちに貼ってるな

>>487
返事書いといただろ
ちゃんと読めよ

小学生の頃は初歩的なビット演算とか楽しくチャレンジ出来たのにな〜・・
今は退屈でコピペで済ましたくなるな・・
好奇心も老化するんだろーか・・ｗ

if( (0 <= a) && (a <= 10) ) 　と等価なコード

if( ((unsigned) a) <= 10 )

2の補数表現の負数をそのまま　符号無で評価すると、INT_MAXより大きくなる事を利用

>>491
汗んブラ世代には至極当たり前田の事項だったりする

手元の gcc-3.4.4(-m86)ではどちらとも同じコードを吐くけど
つまるところ、

MIN <= a && a <= MAX

のコードが

(unsigned)(a - MIN) <= (unsigned)(MAX - MIN)

に変形されるので、条件比較分岐が減る罠

>>481
ハード的にはビット演算しかないわけだが。

>>493
まさか、NOT、NAND、NORゲートだとか言い出さないだろうな？

まあ、>>493は、２０年くらい過去から書き込みしてるらしいから、いいんでね？

まあ、>>495は多値演算バリバリだからい(ry

if( (n-1) & n ) { ,,, }

nが0または 2^xで表現出来る時 のみ実行される

たとえば入力ポートのどれか１つがonであると判ってる時に
多重押しになってないかのチェックに使える

a<=b
ならば
a<=x<=b <=> (unsigned)(x-a)<=b-a

× nが0または 2^xで表現出来る時 のみ実行される
○ nが0または 2^xで表現出来ない時のみ実行される

５００

>>494
他に何があるのか。

まあそれを言ったら終わりだろ。
この3つの論理回路で全てが構成されてるのは明らかなんだし。

つ[ff]

>>503
つ[等価回路]

>>503
フリップフロップだって、結局NAND、NOR、NOTの組み合わせのような気がするなあ。
単純なRS-FFとかNAND 2個で出来るし。

それを言ったら、NORもNOTもNANDがあればできる。
#つーか、TTLの基本はNANDゲートだ。

NANDゲートで全て表現できるとしても、普通NOT、NORゲートは別に作るんじゃねー？

>>506
ECLだとNORが基本だがな

質問
何故に回路(TTLとか）は負論理が多いんですかね？

>>509
ヒント：電子の移動度

>>509　トランジスタは反転回路だから

でも普通、全部が負論理じゃなくて、正論理の部分も何故か存在してるんだよなー

>>512
たとえば何よ

>>513
アドレス/データバスは普通、正論理。

>>509
TTL は特にそうなんだけど、スレッショルドがLレベルに近いから
Hアクティブな信号線はノイズに弱くなる。

>>514
H68TRは負論理でちょっと泣いた事ある。
ちぇー

あと TTL は NPN (2SCタイプ) なので、出力は トランジスタ ON で Ｌ
Ｈは抵抗でプルアップという事になるから
Lの時はその抵抗にムダに電流を流す事になり、

消費電流を減らすには　普段をH 出力にしておいた方が都合が良いというのもあるかもね

ICチップの仕様でプルアップにするのかも知れんが逆ならプルダウンさせるわけで、
プルアップもプルダウンも抵抗に電気を流すので多ければそれだけ消費電力UPするような

TTLは入力がオープンだとHになるからなんじゃ？
CMOSなら不定だけど。

age

age

面白い話題は無いのか？

　　　　　　　　　　_,ｌ;;;;;;;;;;;;;;;;;;;;;;;;;;;l,,_
　　　　　　　　,.ｒ'´,.　　　 -┐　　　':..,ﾞヽ
　　　　　　 ,r' ,::;:'　　　 ,ノ　ヽ､　　　 ﾞ:::.ヽ
　　　　　 ,.' _.,:;:'＿＿＿ _立_　 ＿＿＿;;ミﾞ、　　　　　　　　　￣ﾉ￣|￣
　　　　　.l厄巳厄巳厄　i王i ,.巳厄巳厄巳ｌ　　　　　　　　 　 ,勹 .├‐''
　　　　　l´ , "´ ￣￣￣　`'''′ ￣￣￣｀.:`{　　　　　　　　　´_フ　 ヽ､_,
　　　　　|　l　;;:.,.　　 ::､.　　　　　　 ...　　　'ﾞ|
　　　 ,.-''､.,! ,.::'　　　　ヽ､:.ﾞ、　;;.:'　''　　ヽ　| ,.、　　　　　　　＿＿l＿＿
　　 ./　　､/ ｀ヾｰ─tｯ−ヽ''　　ｋーtr─ﾂ'´〕. ヽ.　　　　　　　 |
　　/ {´ｉ Y::::.. 　 ｀￣￣´.: "i!　::. ､｀￣´ ﾞ:::.､} r､ ｌ　　　　　　　 ｉ,＿＿__
　　| ヾ_,,入;:::..　｀'' " ´.::;　.::i!　::..　 ｀｀`　　:. }ﾂｌ l
　　＼　 ﾉ ヾ ;:::.　　　.:r''　:: ll!　:ヽ;:..:.　　 .:　j,ノ ,!　　　　　　　┬‐┌,┴┐
　　　 ヽ',,;ｌ　 ﾞｉ ;::..　＿ `ヽ､;;,,,,'.ｨ'' ＿,,　.::,;r'1,,,/　　 　 　 　 　 ｌ__　ﾉｌ士
　　ｯｼﾞ::::::|　　ﾞ ,r'´:::;;;;;;;::＞　 弋´;;;;;::::ヽ'"　|:::::ﾞ'ｲｨ　　　　　　ﾉ凵 　l土
　弍:::::::::::l　　/:::;r'´　,,..-ー…ｰ-､　ヾ;:::'､ 　|:::::::::::ﾋ
　 ｼ:::::::::::l 　 i':::,!　　´　　＿＿　　ﾞ　　l::::l:.　|::::::::::ｽ　　　　 　 __ヽ__‐┬┐
　 彡;:;:::::ｌ　　l:::l　　　　　''''''''⇒;;;:,　　　l:::l　 |::::;;ｬ`　　　　　 　　ニ　メ ,ﾉ
　　,r', 广'｀ヽl:::l　::::.　.::　　　　　ﾞ::.　　　l::l　ﾉ^i`､　　　　　 　 　l￣l ﾊヽヽ
　,ｲ（:::j　　　 i::;ヘ 　:;:.　　　　　　 .::　 　l::l'"　 l:ヽヽ　　　　　 　 ￣　 ￣
　|;:ヽヽ　　　l::l　　ヽ　;:....　..　　..　:　 ／l::l　　 ノ ,.ｲ
　|;:;:;:;＼＼　l::l　　　',　:;.:;::::::::::..::.　 /　　l::l,r'' ／;:;:;|

　　　　　♪　　　　／.i　　 ／.i　　／.i
　　　♪　　　　 ∠__ノ　∠__ノ　∠__ノ　　　ｴｰﾗｲﾔｯﾁｬ
　　　　　　 　〈,(・∀・;)ﾉ・∀・;)ﾉ・∀・;)ﾉ 　　　　ｴｰﾗｲﾔｯﾁｬ
　　 　 　　　 └i===|┘i===|┘.i===|┘ 　　　　　　　ﾖｲﾖｲﾖｲﾖｲ
　 　 　 　 　　 〈＿_〈　〈＿_〈　〈＿_〈

armは割り算がないとか。
問題：割り算をビト演算で書け。

ビット演算＋シフト？

加減算とシフト命令を使って書くのは出来るが、ビット演算はキツイなあ

ビット演算で加減算書けるだろ

キツイと言ってるだけで、出来ないとは言ってないよ
加算は
c+a+b
0 0 0 0
0 0 1 1
0 1 0 1
0 1 1 0 c
1 0 0 1
1 0 1 0 c
1 1 0 0 c
1 1 1 1 c

だからxor と or とシフトでは何度か繰り返さないといけないからなあ

演算によっては、SIMDレジスタ駆使して1bit×64並列とかやったほうが
スループット稼げることもあるから覚えておいて損は茄子

ぁなたゎVIPPERですヵ?

Yes! I'm VIPPER!

ぁなたゎﾆｰﾄですか？

論理演算で書いた加算はこんなふうになる。　だからSIMDは巧く使えないと思うのだけど？

function add(a,b:Integer):Integer;
var c:Integer;
begin
repeat
c:=(a and b);
a:=a xor b;
b:=c shl 1;
until b=0;
Result:=a;
end;

full adderか。

NG指定してるので気づかなかったが
奴さんは全然関係ない独り言を唐突に書き込んだだけだから
相手しなくていい

シフトも使わずに >>481 実現しようとしたら面倒すぎて挫折した…

>>534
ああ、なんでいきなり SIMD とか言い出したのかと思ったら
言い出したのはあいつか。やれやれだぜ。

>>534-535低脳ジエン乙ｗｗｗｗ

>>532
いや、それでOK。

たとえばAltiVecで128個の3bitデータを(1bit×128)×3本レジスタに
転置したデータの加算はこれで実現できる。

; dataA : v0, v1, v2
; dataB : v3, v4, v5
; result : v6, v7, v8
vand v31, v0, v3
vxor v6, v0, v3
vxor v30, v1, v4
vand v29, v1, v4
vxor v7, v30, v31
vxor v31, v30, v31
vor v31, v30, v31
vxor v8, v2, v5
vxor v8, v8, v31

AltiVecやSSE2で扱えるのはせいぜい16個のデータまでだから
算術演算は微妙だが、桁上げの無い論理演算主体のコードならスループットは十分稼げる。
DESやAESにあるような複雑なビット転置にかかるコストも軽い(この場合ECBにしか使えないが)

補足。
転置マトリクスをどうやって作るかなんてのは野暮だから辞めてくれな。
スループットの向上が転置のコストに勝るという前提の話。

言うの忘れたけど、相変わらず馬鹿ニートが平日昼間っから寒い発言してるな
4月から有給なんてあり得ないからｗｗｗ
現実で無能の烙印押された人間が2chなら居場所あるとでも思ったかｹｹｹ

言うの忘れてなかったわ。Beログインしてたんで同一人物の証明にはなるだろうｗｗｗ

>>536
自演じゃないですよ。
自演に見えたんですか？間抜けですね。

何このシシカバーブスレ。

馬鹿を相手にするのもまた馬鹿

>>539
俺の職場、4月が最も稼働率が低いんだが。
年度始めって仕事少なくない？

勤務中のネットの私的利用も規制されてない時点で少なくとも大手はあり得ない。
単純に会社の営業力弱くて大手に相手にされてないだけだろｗｗｗｗ

研修中にケータイからなんて俺以外にやっちゃダメ！

うちのサイトのアクセスログみると
大手から勤務時間中に大量に来てるわけだが

うちも、アクセスログでSONY, 東芝、富士通、NEC、日立なんかからのはスゲーアクセス量だ

ニートの屑サイトでもgeetkeeper, Panasonicとかからアクセスがある

俺のところも。
gatekeeper10.sony.co.ｊｐとか。
今日の午前中。
「検索キーワード指定で来てるのでロボットじゃなさそう。

　ふとした瞬間に　視線がぶつかる
　幸運(ｼｱﾜｾ)のときめき　覚えているでしょ
　パステルカラーの季節に恋した
　あの日のように　輝いてる　あなたでいてね

　負けないで　もう少し
　最後まで　走り抜けて
　どんなに　離れてても
　心は　そばにいるわ
　追いかけて　遥かな夢を

　何が起きたって　ヘッチャラな顔して
　どうにかなるサと　おどけてみせるの
　“今宵は私(ﾜﾀｸｼ)と一緒に踊りましょ”
　今も　そんなあなたが好きよ　忘れないで

そーいや折れんとこの基地外サイトにもどういうわけか米AMDからアクセスあったなｗｗｗｗｗｗｗあれはﾜﾛﾀ

どっかの記事で、
仕事中に個人メールや仕事外のサイトを訪れる社員は8割とかいう記事見たっけな
（8割はあいまい。7割、もしくは9割だったかも）

>>552
アクセス規制されてる大手って、具体的にどこ？

団子をいじめないで！＞＜

ヒント：●蔵●杉
基本的に参照できるのはWAN内のコンテンツだけ。microsoftだけに限ってブロックされてない。

●蔵●杉？

アクセス規制されてるところってあるんだねー。とても信じられねーよ。
今時それやっちゃうと
取引先のサイトとか会員制や非公開のBBS、
技術資料検索なんかに多大な不都合を起こすだろうに。
お役所ぐらいかと思ってたよ。
まあそんな会社は早晩衰退していっちゃうだろうさ。

WAN内コンテンツって何だ(w

>>559
おいおい、そんなのは何処の会社でだってあるだろが。
お前、会社勤めじゃないだろ？

●蔵●杉・・・大手・・・？
●蔵●杉？
●蔵●杉？
●蔵●杉？




大蔵省！？？

>>559 イーサーネット
必要な資料は全部WAN内にミラーリングされてるし、外部サイトはかろうじて
msdn.microsoft.comは読めたんで仕事には困らなかったけど何か？

仕事に関係ない外部掲示板に書き込み放題の某GKなんかのほうがおかしいだろ。

>>561　大ヒント：最寄駅名　すまんこれ以上は無理

そのWANの使い方はよくわからん。
おいらは、LANと対比して「インターネット側」と認識していたが。
ひょっとして、支社内LANとの対比で「本社側」という意味のWANもありなのか？

団子のあおり耐性について

団子をいじめないで！＞＜

武蔵小杉か。あそこには何があったっけな。中原ならアレだけど。

内の会社は申請しないとネットができん。
申請してもそれなりの理由がないといけない。
そんなわけでネットすらつなげれん。

とりあえず、イントラとメールはできるが、外部につないで調べ物もできん。
一応ソフト会社なのに・・・

まあ、糞みたいな会社だからね・・・
Nなんて
Sすてきな
Dだめ会社

Nなんて
Eいー
Cかいしゃ？

>>567
管理営業部門？
研究開発部門でネットから締め出し喰らっちゃ今時手かせ足かせ状態になるなあ

　　　　 　 　 　 r'丁´￣￣￣￣｀7¬‐,-､ 　 　 　 　 　 ／
　　　　　　　　r'|　|　　　 　 　 　 |　 |/　 ＞、　　　　 /
　　　　　　　　! |　|　　　 　 　 　 |　 |レ'´／| 　 　 　 |　　 待 て
　　　　　　　　| |　|　　 ／＼　　 |　 |l　 /⊂う　　　　|
　　　　　　　　| |　|__∠∠ヽ_＼　|　 ﾘ　/　 j　　　　　ヽ 　 あ わ て る な
　　　　　　　　|´￣　　　O　 ￣￣￣￣￣｀!　　　　　　〉
　　　　　　　　l'"´￣￣ヾ'"´￣￣｀ヾ::幵ー{　　 　 　 /　　 こ れ は 団 子 の 罠 だ
　　　　　　　 ⊥,,,,,＿､　　　　＿__,,,,,ヾ| l::::::|　　　 　 |
　　　　　　 　 lヾ´ ｆ｝｀7 　 ﾍ´ｆj￣ﾌ　 | l::i'⌒ｉ　　　　|　　　
　　　　　　 　 l　,.ゝ‐ｲ　　　 `‐=ﾆ、ｉ　| l´ (　}　　　　ヽ
　　　　　　 　 l 　 　 {　　　　　　 　 U | l　､_ﾉ　　　 ∠ヘ
　　　　　　　　l　　　/￣　　''ヽ、　　　| l　ヽ_　　　　　　　＼,＿＿＿＿＿＿＿＿＿
　　 　 　 　 　 !　　ﾊ´￣￣￣｀ﾄ、　　|亅〃/＼
　　　　　　　 ,人　ｆ　´￣￣￣｀`ヾ　 j ,!// {_っ ）､
　　　　　　／/　｀ト､_＿iiiii＿_____,レ'‐'//　 _,／　/ｽｧ-､
　　　　,.イl{ ｛ 々 !／´しllllﾄ､￣`ヽ、 // /´,.-、 /彑ゝ-{ｽｧ-､
　　,.イ彑l l > ゞ く l　〃 l|ハ.lヽ、　ﾊVゝヽ二ノ/ゝ-{､彑ゝ-{､彑ｧ-､
,.イ彑ゝ-'l l　（ (,) レｼ′　　 !l　｀ｿｧ'´　 　 _ノ7{､彑ゝ-{､彑ゝ-{､彑{
ュゝ-{､彑l l　 ` -イﾍ　 　 　 !ｌ　//　/⌒ヽヾ/_ゝ-{､彑ゝ-{､彑ゝ-{､
　{､彑ゝ-'l l f⌒Ｙﾊ　',　　　　!l/ /　ヽ_う ﾉ /-{､彑ゝ-{､彑ゝ-{､彑ゝ
彑ゝ-{､彑l l｛ に!小　ヽ　　 /!l /　　 ,／　/彑ゝ-{､彑ゝ-{､彑ゝ-{､

ぷえ新卒１年目で３社目かい？

並べ替えて杉村大蔵かもしれんよ

東横線とか南武線みたいなローカル線しか通らない武蔵小杉みたいなド田舎に NEC みたいな大手があるわけないだろう

あと GK 連中はマじゃないからな
連中のいる会社の頭にはSさえつかない可能性も高いぞ
なのに同じ目でみられるんだよなぁ・・・

>>573
常識的に、オフィスは営業拠点だけじゃないでしょ。

>>573
ん？あのデカいツインタワーはどこの会社のビルだろうな？ｗｗｗ

>>575
今そんなんできてんのか？ そういや工事してたな
あのへんでツインタワーってったら新川崎じゃないのか？

連投すまんが、>>574 皮肉の通じない奴だな
むかいがわらだっけか？ 専用改札のあるのは

どこの会社でもいいがつまらん奴もいるもんだな

ま、そういう事。

>>532の減算版

function sub(a,b:Integer):Integer;//a-b
var c:Integer;
begin
repeat
c:=((not a) and b);
a:=a xor b;
b:=c shl 1;
until b=0;
Result:=a;
end;

加算を利用する場合
function sub(a,b:Integer):Integer;//a-b
begin
result:=add(add(a,not b),1);
end;

団子って、痛いな、痛すぎる。
実生活でよほど人から認められてないんだな。

そんなに攻めるなよ
許せないおまえらも十分キモイYo!

適当な数値から任意の位置の4bitの数値を取り出したいんだけどどうしたらいい？

連続した４ビットなら

c 言語なら (x >> bitpos) &( (1<<4)-1)
delphiなら (x shr bitPos) and ( (1 shl 4) -1)

>>584
ありがと、試してみる。

>>563
>そのWANの使い方はよくわからん。
つか、「WAN内コンテンツって何だ」って訊かれて
物理層I/Fを答える莫迦も、そうそういないけどな。
いつのまにか
>勤務中のネットの私的利用も規制されてない時点で少なくとも大手はあり得ない。
この主張はウヤムヤになってるし。

>>586
団子「WAN内コンテンツ」
団子「勤務中のネットの私的利用も規制されてない時点で少なくとも大手はあり得ない」
他人「そのWANの使い方はよくわからん。」
団子「インターネット」

別にコンテンツが何かを意味してるんじゃなく、「WAN内の」ってところにひっかかりが
あるわけで、「WAN内のコンテンツ」だと「普通にインターネットのコンテンツのことじゃん」
って自分で気づいて自嘲したものだと思うな。
俺なら、「インターネット(^^:)」とか明らかに自嘲したようなリアクションで答えるところだけど。
まあこんなところも嫌われる性格がにじみ出たんだろうな。

確かに間違った使い方かもしれんが、会社規模が大きく、クラスCで納まらないほど
広域（全世界的）に広がったイントラネットだとLANというよりWANと言った方が
しっくりくるかもしれんけど、それならきちんと謝ってから訂正しろよ、なあ。

VPN網だね、アレは。メチャクチャ広帯域。
数GBのファイル転送が数分で終わる。

うちの知り合いが通い詰めてる会社は、URLに bbs とか 2ch が入ってるだけで
閲覧自体できないらしい。それくらいやっても当然とは思うがな。
まぁ、BBSも見ればたまに役に立つことも在るかもしれんにしても、GETやHEADを
許すまではアリにしてもPOSTは弾くのが当然でしょ。

自宅に串立てて自宅のIPの足しかつかないようにすれば文句も言えまいて。
まぁ、私的利用をそこまでして必死に申し出る香具師もどうかと思うけどな。

>>588
「当然」と「思う」のは勝手だがな。

独自ドメインもとってない中小無名企業なら2chみたいな掲示板に足跡つけらてても大して痛くないかもしれんが
大きな会社だとそうもならんと思うのよ。

>>590
たとえばこんなの？

GateKeeper**.Sony.CO.JP

俺、釣られてる？

なんて反省のカケラもない奴だ。
ここまで厚顔無恥だと無視するしか手は残ってないな。

とりあえず俺の隣にこんな奴がいない幸せを噛み締めてる

しっかし、団子っていつもいつも叩かれまくってるってのによくもまあ現れるもんだね。
何考えてるんだろ。マゾかな？

>>592 ETC作ってる？

>>593 何を詫びる必要があるのかサッパリ。名無しで書き込んでる人にに下げる頭はないっすよ正直。
世間の影響力の小さい会社や働いてない人だと、堂々と平日日中に2ｃｈでカキコできていいよね、って話。

それはVIPPERだからさ

>>594
なんかこんなソフト作ったとか実績のある人間にそのハンドルネームでも付けて意見されたら
へこむけど、名無しで攻撃するのは基本的になんたらの遠吠えに等しいからね。
実際実績皆無なんだろうけど。

>>591
漏れのどう考えても仕事に役立ちそうに内部ログにも来てるよ、それ。
ほかにも曰立とか講壇社とか花押とか。

>>598
本当に実力のある者はHNなんてくだらないものつけない

つーか、そもそもHNなんて変な略語使わない。

HN持ってないオンラインソフト作家っているのか。へぇ。

これでどうだ！　論理演算だけだと思うぞ
function unsigned_div(x,y:dword;var modu:dword):dword;
var a,b,c,v,w,lpc:dword;
begin
　a:=0;
　b:=0;
　lpc:=1;
　 repeat
　　a:=a shl 1;
　　if (x and $80000000)<>0 then a := a or 1;
　　x := x shl 1;
　　b := b shl 1;
　　w:=y;
　　v:=a;
　　 repeat
　　　c:=((not v) and w);
　　　v:=v xor w;
　　　w:=c shl 1;
　　 until w=0;
　　 if (c and $80000000)=0 then begin
　　 b:= b or 1;
　　 a:= v;
　　 end;
　　 lpc:=lpc shl 1;
　 until lpc=0;
　　 if @modu<>nil then modu:=a;
　 result:=b;
end;

まぁ確かに漏れはオンラインソフトはPN名義にしているからハンドルは内輪にしか使わないなぁ。

まともな作者ほど口調や言い回しに気を使うものだ

>>601
そもそも「ハンドルネーム」の時点で変。
(wiki には言い訳がましい理由が書いてあるが)

高飛車な言い方もTPOをわきまえて使ってくれ。
この板じゃ初心者じゃなくて、フリー（じゃなくても）ソフト作家ばっかりが
集まってる（見てる）と思ってたら（ここに突っ込むなよ）
もう少し言い方を考えてみてもよいだろう？
他人をもっと尊重しようぜ。

これで四則演算はビット演算（論理＋シフト）だけで出来る事となった

次はビット演算だけによるループカウンタの効率的表現方法だな

一つのアイデアは Ｍ系列を使う事

へ？ハンドルとPNって普通同一じゃね？
PNとHNが別ってならそれでもいいけど

そのPNでも教えていただければ、発言に説得力あるわな。
逆に言えば名無しに成り下がってる時点で、そこらの能無しと同じ立場として発言してるってことじゃね？

別に謝れとかは言わんけど、君が書き込むたびに騒動になるのは
なんか問題があるとは思わない？
同じソフトウェア仲間から総スカン喰って平気なの？
俺も当然webで公開してるけど、そんな挑発に乗って
ここで公開しようって気には全然ならないよ。

トリッパー作ったくらいで天狗になるな
下を見る前に上を見ろ

>>607
ソフト作家ってのは自分自身の時間を使ってソフトの企画から設計・コーディングまで自分でやって
自分の名義でソフトを出してる人だと思ったが違ったかな。
客から、上からの指示ありきでせこせこコード書いて、その所有権を勤め先や会社に譲渡して、
それを対価にしてる職業プログラマはその範疇に入らないと思うけど。

両者には画家と塗り絵職人の違いがあるし。
見習いの情報学科の学生とかも含め、この板っての全てが作家やその卵ってわけじゃないのは
普通に考えればわかることだけど。

俺の小学校からの先輩が某有名オンラインソフトの開発メンバーだけど（今のとこ
唯一尊敬できる人）はこの板はそもそもレベル低すぎて見てないっていうし、そんなもんだと思う。
それに>>1にあるようにここ厨スレだしｗｗｗ

つまり「ここには挑発しに来てる」と公言しているわけですか？
そういうことならこっちは了解です。バイバイ。

レベルが低いところで、どれだけ面白いことが出来るかを楽しんでるんだからさ。
>>537みたいにな　未完成品はちゃんと完成させろよ

>>608
では早速M系列とやらの講義に入ってくれ。

「唯一尊敬」は言いすぎました。フリーソフトはいっぱい使わせてもらってます。
>>613ですが何か？

ごめん

>>517は俺ですが何か？

>>517,613　　正直、本気で謝る。

>>537が俺

ではお言葉に甘えまして。
まずは背景の説明を

>603 のコードではビット幅だけループする必要があるが、
ここでfor文を使ってしまうと、論理演算だけで実現した事にならない。
そこで、１をビット数だけ左シフトした時にオーバーフローしてゼロになる事を利用してループカウンタとしている

しかし、当然ビット幅を超える回数はこの方法では指定出来ない。

出来るだけ少ないビット演算でループカウンタが実装出来ないかというのが、現在の課題である

いいえ何も。お引取りください。

団子は秋葉原でコンデンサとか買ってきて論理回路作った経験は？

>>618だから、未完成品は完成させろって。

>>603
読めないからCで書いてくれませんか

>>618
beがついてるんだから>>537が誰なのかは判ってる
何度もリンク先を間違うぐらい沸騰してるのか
そんなことじゃ、挑発してるというよりされてる方じゃないの？

>>623
var ⇒　参照渡し　cならポインタ渡し
:= ⇒ =
dword ⇒ unsigned
$ ⇒ 0x
repeat 〜　until 条件⇒ do while(!　条件　)
result:= ⇒ return

>>622
その考え方を応用したソフトなら（どんな名義で出してるかはあえて言わないが）既に世に出てるよ。

どうもです
if @modu<>nil then modu:=a;
これは
if (modu) *modu=a;
かな
Cと書き方逆っぽいけど

>>627
そう。その通り。 @ はcの& 演算子相当。

　参照渡しだから単純代入になってる。

>>609
ハンドルはあくまで只のハンドル。名前ではないのでハンドルネームなんて言葉は(本来)ない。
#つまり、チャットなどで便宜上使っているニックネームのようなものだな。

ペンネームはあくまで別名としての名前。書いたものを発表するために使っている名前だな。

漏れ自身はここではなんら議論に関与していないので、PNを公表する意義は見出せないな。
そういう意味では、無名化していると言う点では誰でもない。

>>545
>勤務中のネットの私的利用も規制されてない時点で少なくとも大手はあり得ない。
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　~~~~~~~~~~~~
>>590
>大きな会社だとそうもならんと思うのよ。
　　　　　　　　　　　　　　　　　　 ~~~~~~~~~~

むかし、メモリが少なかった頃のVRAMが8bitやら16bitやらの時代のブレンド処理
332とか 555とかの(a+b)/2 をこんな方法で並列してやったような記憶もあるな。

もはや、こういうのに興味があるのはdel厨だけか。
インラインアセンブラを組み込んでる言語だけあるな(^^

>>630
勤務中の2ｃｈへの書き込みが許されてる企業があるなんて知らなかったんだ。
視野が狭いのでごめんね。

>>団子
VIPPERスレにいきましょうか？

一つ言っておこう。
会社で与えられた業務だけをやってる奴は
こんな板にまでやって来ないもんだ。
ちょっと舞い上がってない？

俺も思うところが一つある。
勤務中に2chに来るのを許してるところなんて無いだろうって思う。
それでもここにやって来るのは会社への帰属意識が低い甘ちゃんな奴だろう。
でも昼間アクセスするのが会社員だけではない。
アマチュアソフト作家の半分程度は学生だと思うし。
それを即ニート扱いは無いだろう。
またニートや引きこもりがここで喧嘩するとはとは思えん。
それほどの意気があったら社会に出てるって。

どうでもいいですよ♪

>>629
Wikipediaに書いてあることの劣化コピーなんて求めてないから。このＵＲＬ貼れば済むことでしょ。
http://ja.wikipedia.org/wiki/%E3%83%8F%E3%83%B3%E3%83%89%E3%83%AB%E3%83%8D%E3%83%BC%E3%83%A0
浴衣（ゆかた）が正しくは湯帷子（ゆかたびら）だとかいちいち文句つける人ですか？

うちはご覧の通りコテハンとペンネームの区別がない人間なんで（というかコテハン名義で
作品作ってきた人間なんで）その手の揚げ足取りとられても、はい、覚えておきます、
って答えるほかないです。
そういうやり方で自分の作品（ソフト・イラスト・etc..）の一部または全部を公開してる人と
長く馴れ合ってたから感覚ズレてるかもしれんけど。

自分が話題に関与してないって解ってるのに引きずる理由は理解できん。
ちなみに、あなたが何かのソフト作家だなんてあたしゃまったく信じてないし。
一言一句、なにもこたえるものもなく右から左に抜けていくだけです。
それなら吉野家や宇宙ヤバイコピペのほうがまだ印象に残るよ。

自分がクリエイターだって言いたいんならきちんとそれを証明すればいいだけの話だと思うのね。
「自分は本当は作家だけど正体は明かせない」・・・なんて虚勢にしか聞こえないんで
証明できないなら黙っておくほうが綺麗です。
2ちゃんねらーは虚言大好きだから、そういう風に思われても仕方ないってこと。
それを理解したうえで2ｃｈやってるんじゃないの違うの？

>>635
日中平気でサボる駄目社員っぷりを開き直られてもこまりますが＞＜

>>638
海外では本名で出す場合が多く思えるんだけどどうなの？

よくわからんけど、研究をしてその結果を公開するような人は本名？

>>638
＞ソフト作家ってのは自分自身の時間を使ってソフトの企画から設計・コーディングまで自分でやって
＞自分の名義でソフトを出してる人だと思ったが違ったかな。
これに対するレスだろ。ちゃんと反応しろよ。

普通に本名でやってるサイトも持ってるけど。
2ch関連かそれ以外かで線引きしてるつもり。
中の人自身のソフト開発の暇が削られすぎなんで、コテハン名義のソフト開発は
縮小していこうかなと思ってたりもする。

・∀・）っ-○●◎名義で出してるソフトはあって、それが俺の作品だって誰もがわかる。
「デフォルトの名無しさん」名乗っててもどんな作品作ってるかすらわからないし、
何も作品無い人かもしれない。そういう話。

＞客から、上からの指示ありきでせこせこコード書いて、その所有権を勤め先や会社に譲渡して、
＞それを対価にしてる職業プログラマはその範疇に入らないと思うけど。

（唯一）尊敬している人がいたなら、そういう人になりたいって思い
振る舞いなんかマネするものじゃないかな？
その尊敬する人から逆にどう見られてるのか気にしないものなのかね？

>>644
いやきっとそれは知識量を尊敬してるのであって
きっと人品卑しからない人って訳じゃないんだろうて（ｗ

長期間、所謂コテハンで書いていれば、
名無しに対してそういうstanceになるのは、ある意味当然だろうね。
とか書いてみるテスト。

コテハンというものは、情報に信頼性を付与する程度の物。
有益な情報を提供する時のみに用いれば、価値は上がるだろうね。

>>642
ちょっとは考えてくれよ。
いくら名無しだとはいったってこの板にいるんだから何らかの作品を提供してる人だって
結構いるだろうって推測ぐらいつくだろ？
自分に噛み付くその程度の低さを思ってそう言っているのかも知れないけれど
無頼者に対してはそれなりの態度で臨むものだよ。
自分のサイトを公表するかどうかってのは個々人のそれぞれのポリシーがあって隠している
わけなんだから挑発されたってコロコロ考えが変わるわけないじゃん。
逆にコロコロ考えを変える人は大したことはない人だよ。

作品出してるか出してないかだけで技術を判断するのはおかしい
技術があっても既に作りたいものが世に出てれば作らないだろうし、
出しててもそれが本当に素晴らしいものなのかどうか
ソースコードに無駄は無いのか、バグ取りは完全か

てか、自分より技術が下のものを馬鹿にしてる時点で氏ねよと思う

だからさ、面倒だから漏れはこのスレではソフト作家を騙る能無しでいいよ。
漏れがきちんと名乗りたいスレでは名乗るってだけの話だから。

おいおい、ガラスのハートの壊れやすさ自慢大会会場かよ

下のものに学ぶっていうことを覚えたらもっとしっかりした知識が身につくんだがなあ。

>>650
おまいバカ？

>>646
コテハンで検索してみても貴殿のサイトは発見できませんでした。

まずはジョンソンカウンタ
これはbit幅の2倍の値がカウント出来る。

ジョンソンカウンタは シフトしながらMSBの反転をLSBに入れる事で実現出来る

ジョンソンカウンタ方式による　(N+1)*2 回のループの例

repeat
x:=( ( x shl 1) or (((not x shr N) ) and 1)) and ((2 shl N)-1);
until x=0;

>>648
仕事以外ではプログラムやりません
先越されてるから、もっといいものがあるから、ソフト作りません
なんてのはプログラミングに対する愛がないんじゃね？

模倣からでも地道に始めてやがて独自性を開拓していく、それが技術立国ニッポン。
俺もパブリックドメインとかのコードをパクリマ・クリスティ。

５年やって周りと同じレベルにならないのはダメ社員。

おいおまいら！
タイトルを１００回読もうな！

単純シフト方式で 32bitのレジスタで32回
ジョンソンカウンタ方式で64回までループを回せるようになった。

しかし1万回とか100万回のループをどうやれば実現出来るのか

ジョンソンカウンタは MSBを単純に反転してMSBに入れたが
これをMSBと途中の複数のビットとの論理演算をしてLSBに返したらどうなるかを考える
こういう時の論理演算は xor

x:=( ( x shl 1) or ((( x shr 15) xor x ) and 1)) and $ffff
とすると 1から初めて1に戻るまでは255回　だいぶ改善された。


x:=( ( x shl 1) or ((( x shr 14) xor x ) and 1)) and $7fff;
これで x=1から開始して x=1に戻るまで 32767回かかる

こういうビットサイズ N で (2^N-1)の周期が出るのをＭ系列というらしい。

> 勤務中の2ｃｈへの書き込みが許されてる企業があるなんて知らなかったんだ。

裁量勤務になれば会社の設備を使わないで2chへのアクセスは許可なんていらない。
国内大手だと優秀な奴から駄目な奴まで様々。むしろ不遇な境遇に居る優秀な人間が
出ていくから駄目な奴が多く感じるぐらいだな。そんな環境で生き残るには

>　大きな会社だとそうもならんと思うのよ。

みたいな社畜くさい発言しているようじゃ埋もれるだけだな。

> 仕事以外ではプログラムやりません

はいそれが？会社で面白そうなモノを選んで作れる立場にいますから。
もっともその立場になるには運と実力が必要。社畜には無理。

裁量労働制じゃないところは殆どなかろうが、それでも大手は会社内に普通はいる
（サテライト勤務できるとこあるのかな）
施設内から2chは自由時間でもちょっとまずかろう
それに自由なテーマなんてそれほど選べないもんだし
大人数でシステム開発を行うことがほとんど
（でも意欲的なプロジェクトへの参加はありだね）
実力のある奴は先進的な面白い開発を行い、メンテをダメな奴に引き継いで
次から次へとプロジェクトを渡り歩くことが出来るが、そんなのは100人に1人ぐらいだ

また、自分でプロジェクトを立ち上げることも可能なわけだが、
そういう立場だと実開発に携われないで管理業務に従事することになっちゃう

>>661
> 実力のある奴は先進的な面白い開発を行い、メンテをダメな奴に引き継いで
> 次から次へとプロジェクトを渡り歩くことが出来るが、

実力だけじゃなかなか無理。強引に過去の仕事を切り離す意思が無いと引き継いだ
駄目な奴から変な依頼が来て潰れる。

> そんなのは100人に1人ぐらいだ

100人に1人ぐらいになれんでどうする？
部長だって100人に1人ぐらいじゃねーのか？

部長は45才ぐらいじゃないとなれないし、課長だってプログラム組むことは有り得ない
ようするにプログラマーから管理者に転身しちゃうわけだ
いまのところまだまだ開発に従事したいと思ってる

問題はそこなんだよね。漏れの給料だと自前で確保できる仕事じゃ回らなくなってくる。
そこで部下をつけて仕事をこなして稼いで来いって話になるわけだがそうなると当然、
管理に時間を取られるし管理能力が必要になるしで結局管理職になるのと変わらなくなる。

俺は100人に1人にはなれそうもないな。
評価もSランクには到底なれないし。
情けないけど俺にはこれが現実だ。

「デカイ企業」じゃないけど、生越ちゃんの会社なんかはそれこそ
Rubyの開発で国からも金もらってたりするし、好きなことやれてるってのは
まぁわかる。
てか、そういうレベルのプログラムを個人レベルででも作れるってのは理想。
そうなると、１から会社作ったほうがよくね？的な話に。

あと、研究所勤務とか？ああいうところこそ、それこそビット演算とかプリミティブなレベル
の作りこみできるわな。
ただアレは学位持ちのPDが大学や国研からダイレクトに企業にわたってくるもので
現場上がりにやれることなんて皆無だわな。

> 部長は45才ぐらいじゃないとなれないし、課長だってプログラム組むことは有り得ない

100人の中の1人は無理じゃないって話のたとえ話はそういう方向に行くかな？

さすがに部長はコード書かんが最近はうちの会社では部署によっちゃ課長でもコード
書いていたりする。まぁ、課長職になってコード書けなくなった優秀なエンジニアが
退職するケースが増えていたのが原因かと思われるが・・・

> 情けないけど俺にはこれが現実だ。

努力はしろよ。自分が討ち死にしても次の若者がその道を引き続き開拓してくれれば
いいじゃないか。

100人に1人のエースがこんなとこに来るはずないと俺は思う。

俺は実力が100人に1人とは思っていない。なぜなら運も重要だからな。

> それこそビット演算とかプリミティブなレベルの作りこみできるわな。

それは目的じゃなくて手段だからな・・・そういうのをやりたければ研究所だろうね。

>>668
別にそれほど悲観してるわけじゃないよ。
一応同期の中じゃトップクラスだと自負してる。
(A評価で特別ボーナスも貰った経験はある）

>>672
器用貧乏になるなよ。重要な事は周りに、
「マネジメントよりエンジニアやらせたほうが得だ」
と思わせる事だ。ただし組織が壊れるような事や閑職に追い込まれないように注意しろ。

>>673
それは無理だって。
A評価だって普通に開発だけに従事してたら貰えっこない。
自分で目標設定して必要な人材（社内にリソースが足りない場合は社外からも）
集めて特許も何件か出してそれなりの成果をださないと。

>>668
> 書いていたりする。まぁ、課長職になってコード書けなくなった優秀なエンジニアが
> 退職するケースが増えていたのが原因かと思われるが・・・

ちょっと気になったんだけど、プログラミングできる人は
ずっとプログラマであり続けたいと思う、ってこと？

>>675
それは違う。
数年前から課長職だなんて無駄だという方向に会社の意識が向いてきてて
中間管理職を無くして、言わばプレーイングマネージャーとしてもっと活用しよう
ってことになってるだけ。
課長なんて役職はほとんど消えて、管理は部長にがんばってもらうというようになっている。

LSB xor MSBで　Ｍ系列になるビット数は 2,3,4,6,7,8　と小さい時は連続してあるが
大きくなると　15, 22,30,40 　しかない。
またピッタリ16bit,32bitのＭ系列は作れない。

　x:=( ( x shl 1) or ((( x shr 14) xor x ) and 1)) and $7fff

上位ビットは、下位ビットがシフトされているだけなので
最後の and 命令を取り外してしまう。
　x:=( ( x shl 1) or ((( x shr 29) xor x ) and 1))

ループ回数を1万回とかの場合は、この演算を
1万回回した時の表を用意しておいて使う事になる

いつからこのスレはマ板に移動されたんだ？

ビット演算でする加算の桁上げ処理を減らす方法はないかな

調べると回路技術でも似たような問題があって　キャリールックアヘッド　というので解決してるそうだ

>>679
おまいの使ってるCPUでは、キャリーフラグ立てるのに何か特別な命令を追加発行しなきゃならないのかね？

普通は、キャリーフラグは　加減算と、シフト・回転だけだろうけど
このスレ的には加減算は禁止だから　シフト・回転だな。

で、それが何か >>679の問題と関係するのかい？

>>680 が何に噛み付いてるのか解らん。

>>679
キャリールックアヘッドは、キャリーの計算を並行してやっちまうという
手段なんで、ソフトであれやると (計算が面倒な分) 却って遅くなりそうな
気がしなくもないんで、いっそ表引きするのはどうか。

>>532 ビット演算だけの足算
>>580 ビット演算だけの引算
>>603 ビット演算だけの割算

半加算器を繰り返し使って実現してるから、最悪(ビット幅-1)のループになるんで
ループしない方法は無いかという事だね。

あれば特許モノだろうな

つか、ハードウェア上じゃビット演算だけで加減乗除してるんだから、わざわざ二度手間する必要あるのか？
CPLDとかの設計なら必要かも知れんが

意味はさ・・・・　まず、面白いから。

次に高速化に使える場面があるかもしれないから。
たとえば、32bit1ワードに4bitのデータが8桁入ってる場合に　２つの平均を出すのを高速にやりたいとかさ

そう言うチップ作って組込んだ方が速いぜ。
いまどきのカスタムCPUは、ニーモニックまでカスタムできるからな。

で、それをどこに頼むんだ？　
そこらのベンチャーが気軽にASIC起こせるような環境なんて日本にゃない。
そういう面じゃ台湾どころか韓国にも完全に負けてるぜ。

>>686
>>685 の前者が理由の殆どだと思うが。

それより
>いまどきのカスタムCPUは、ニーモニックまでカスタムできるからな。
1. 「カスタムCPU」とは？「チップ作って組込」むのではなかったのか？
2. ニーモニックはアセンブラが認識するもので、プロセッサとは関係ない。
3. 「カスタムできる」→「カスタマイズできる」では?

素直に四則演算が、ビット演算で代用可能だというのを厨房でも実感出来るというのが　このスレにとっての必要じゃないのかな

NANDゲートがあれば何でも作れるよ。

>>687
そりゃおまえさんの視野がせまいんじゃないのか？
気軽の程度にもよるけどな。

取り合えず一発作成で数百万あれば作成できると思う。
請け負ってるところは結構大手でもあるし。

俺は全然知らんが、取り合えずアルテラに連絡して紹介してもらえば？

ASICは全然向いてないんじゃないのかな？
ワイヤードロジックで作成しなきゃ。

で、【ビット演算だけの掛算】はドコにありますか？

function unsigned_mpy(a,b:Cardinal):Cardinal;
begin
result:=0;
　 while b<>0 do begin
　 if (b and 1)<>0 then result:=add(result,a);
　 a:=a shl 1;
　 b:=b shr 1;
　 end;
end;

掛け算の原理
a*b = (a*2)*(b/2) = (a*2)*(b div 2 + 余り) = (a*2)*(b div 2) + a*余り

b を左シフト、aを右シフトしながら
ｂが奇数の時のaの値を合計してゆけば等号を満たす

×b を左シフト、aを右シフトしながら
○b を右シフト、aを左シフトしながら

筆算をこう表現するんだ・・・
勉強になった

コレってビット数を数えるのに利用出来ないかな

a,bの合計ビット数は　ビット数を数える関数BitCntを使って

BitCnt(a ) + BitCnt( b) = BitCnt(a and b )*2 + BitCnt(a xor b) ・・・・・無理かな

…？

とりあえずその式は正しいですね

演算しないで全部パターンをROMに焼いておけば簡単じゃね？

気分転換に

1Wordの変数edgeL,edgeRについて
必ずedgeL<=edgeRになるように必要に応じてスワップする関数をビット演算のみで作成していただけますか？

>>704
計算なしでいけるぞ。
配列f(a,b),g(a,b)を用意する。
fはaとbの大きい方の値を返す。
for(a)for(b){if (a>b) f(a,b)=a; else g(a,b)=b;}
だ！

ブランチフリーでお願いします

条件は　
　１、分岐命令を使わない
　２、四則演算を使わない

代入、論理、シフト・回転のみ？　符号付か符号無しかは自由？

組み合わせ問題だから今ひとつ
>>580の減算で 結果ではなくcのMSBを返して
f= (a xor b) and c,msb　
a=a xor f
b=b xor f

>>707
符合付き
四則演算は加算と減算のみ使用可でお願いします

符号付か。　オーバーフローフラグも使っちゃだめ？

加算と減算だけ？　and もシフトも無しかよ

可です

加減有りならこれでいいや
inline void swap_if(WORD&a,WORD&b){
    WORD c = a-b>>16 & (a^b);
    a^=c;b^=c;
}

ダメだオーバーフローした時に巧く動かないや

WORD はwindowsでは符号無16bitの筈なので (a-b)>>16 はゼロになるのだと思うのだが

>>714
つ 整数の昇格

つまり int が32bit以上の環境を仮定してるわけか　なるほど

struct IO
{
　　struct
　　{
　　　　unsigned short AAA 2:
　　　　unsigned short BBB 2:
　　　　unsigned short CCC 2:
　　　　unsigned short DDD 2:
　　　　unsigned short EEE 2:
　　　　unsigned short FFF 2:
　　　　unsigned short GGG 2:
　　　　unsigned short HHH 2:
　　}BIT;
};

こんな構造体があったと仮定して
unsigned BBBに0x01をセットした場合、上位4ビット目（2^12ビット）
に値が入ると仮定していいのでしょうか？

少なくともx86では下位3〜4ビット目に0x01が入る

その構造体がさすのがIOレジスタの場合
やはりBigエンディアンとLittleエンディアンとでは違うものなのでしょうか？

今、作成しているプログラムがSuperHというCPUなのですが、
それを作成するための統合開発環境HEWが吐き出すIOレジスタのヘッダファイルが
こんな形です。

しかし、プログラムを作成する際、雛形の作成においてCPUの種別として
Bigエンディアンを選んでもLittleエンディアンを選んでも同じヘッダを作成します
その場合、きちんとIO設定できるか不安で質問しました。

>>718
大嘘を書くな。ビットフィールドが下から使われるなんて規格はない。

>>719
環境ごとに調べるしかないわけだ。CPUによっては、8ビットアクセスと32ビットアクセスで
出力されるラインが換わる可能性もあるから要注意。

> ビットフィールドでは先に書いたほうが上位ビットになるか、下位ビットになるかは
> CPUと処理系に依存する。H8用GCCの場合、先に書いたほうが上位ビットになるが、
> CPUやコンパイラが異なる環境では、逆になることもあるので注意しよう
> (たとえば、パソコンのx86系CPUはリトルエンディアンなので、通常、先に書いた方が
> 下位ビットになる)。

まぁとりあえず>>718は嘘だな

>>719
外付けのI/Oの場合はエンディアンが違えば違う事になります。

内蔵Ｉ／Ｏの場合、エンディアンを変更するのですから、結果としてワードアクセスでは同じ事になります

ビッグエンディアン
しばしばリトルエンディアンよりも優れたものとされている

リトルエンディアン
しばしばビッグエンディアンよりも優れたものとされている

>>724
リナクス　 -> リナックスを参照

リナックス -> リナクスを参照

とかあったなぁｗ

真コンピュータ用語辞典だっけ？

>>725
広辞苑で循環参照したのがあったような気がするが何だか忘れた。

キーワード【会社 団子 コード 人 bits レジスタ 論理 】

>>726
同志よ、よく覚えてたなｗ

エンディアンのネタ元はガリバーのこびとの国

なにをいまさら？

エンディアン嘘ツカナイ

卵は真中から割る。

memsetを超える高速,memsetをCで作ろうとしたが、さすがに無理だった
やはりアセンブラか・・・Cでは無理かな？

絶対無理

むしろCからmemsetを超える高速memsetを生成できる
究極の最適化Cコンパイラを作るべきかと。

やるとするなら再配置される命令アドレスを最適化したり
memsetを呼び出すメモリ側のアドレスを最適化したりとか？

_memset
MOV.L R12,@-R15
MOV.L R13,@-R15
MOV.L R14,@-R15

MOV R6,R1
MOV #H'1F,R2
MOV R4,R6
CMP/HS R2,R1
ADD R1,R6
BF/S @H'1510:8
MOV R5,R13
MOV R6,R0
AND #H'0F,R0
MOV #H'01,R12
CMP/GT R12,R0
MOV R0,R5
BF/S @H'14C8:8
SUB R0,R1
ADD #H'FE,R5
MOV R6,R2
ADD #H'FE,R6
CMP/GT R12,R5
MOV.B R13,@-R2
BT/S @H'14BA:8
MOV.B R13,@R6
CMP/PL R5
BF @H'14CE:8
MOV.B R13,@-R6
EXTU.B R13,R5

MOV R5,R7
SHLL8 R7
OR R7,R5
MOV R1,R7
SHLR2 R7
SHLR2 R7
MOV R7,R2
SHLL2 R2
MOV R5,R14
SHLL16 R5
SHLL2 R2
CMP/GT R12,R7
OR R5,R14
BF/S @H'1504:8
SUB R2,R1
MOV.L R14,@-R6
MOV.L R14,@-R6
MOV.L R14,@-R6
MOV.L R14,@-R6
MOV.L R14,@-R6
ADD #H'FE,R7
MOV.L R14,@-R6
MOV.L R14,@-R6
CMP/GT R12,R7
BT/S @H'14EE:8
MOV.L R14,@-R6
CMP/PL R7
BF @H'1510:8

SHLL2 ・・・・・って早速インターフェース付録のSH2か？

MOV.L R14,@-R6
MOV.L R14,@-R6
MOV.L R14,@-R6
MOV.L R14,@-R6
MOV #H'01,R12
CMP/GT R12,R1
BF @H'1524:8
ADD #H'FE,R1
MOV R6,R2
ADD #H'FE,R6
CMP/GT R12,R1
MOV.B R13,@-R2
BT/S @H'1516:8
MOV.B R13,@R6
CMP/PL R1
BF @H'152A:8
MOV.B R13,@-R6
MOV R4,R0
MOV.L @R15+,R14
MOV.L @R15+,R13
RTS
MOV.L @R15+,R12

↑このmemsetをCで書くとどうなるんだ？

遅くなる。

上記のmemsetはHEWで作成しました。
最適化はスピード優先です。

どうやっても自作のメモリクリア関数とmemsetでのゼロクリアとでは
memsetのほうが速かったです（最適化なしのmemsetなら自作のほうが速い）

他のCPUではどうなのかわかりませんが、SH-2では私ではmemsetに勝てる関数は作成できませんでした
なにか知恵がありましたら教えてください。


・・・あとひとつ
MOV R10, @R14+
と
MOV R10. @-R14
では速度は変わらないのでしょうか？
上のmemsetではやたら@-R6などやってましたけど・・・

とりあえず
MOV　R0 ,@-R15
と
MOV @R15+, R0
ではサイクル数など同じでしたけど。

SHは特殊な最適化を要求されるから、

　Ｃで最適化し易いコードを書く　＞　ヘタにアセンブラで書く

となってしまう。
　最適化し易いコードってのは、構造体のサイズをアドレッシングに合わせて小さくするとか
　ある程度のサイズの関数に書くとかの事ね


アセンブラで書くとなると
最適化用に、HEWにソフトウエアでシミュレートする機能があるでしょ？
それ見てスロットを埋めてゆかないといけないのさ
これがなかなか厄介なパズル

ようはSHという環境ではCでmemsetの最適化ありにかなうプログラムはできないということじゃないの？

だろうな。　単純な処理だから可能な殆どのパターンは持っていて、
それを、可能な組み合わせを全部調べてもっともスロットが綺麗に埋まるように配置してるんだろう。
これに人力で勝とうとするとアルゴリズムで勝つしかないだろうけど、

memsetじゃ、やりようがないだろ？

じゃあ、memsetに一番近づける、高速自作memsetをCで書くと、どう書くのですか？
アセンブラとCに精通しているみなさん教えてください。

なんかスレ違いでないか？

>>748　昔、for と switchを入れ子にしたコードで、へーというようなのを見たことがある。

確か 32bitマシンで バイト境界になるようにポインタの下位2bitでswitchし
ループは32bit単位で行うと

そのヒントで考えてみたら？

1からインクリメントしていった時の一番右の立っているビットの位置の列が
欲しいんですがいい方法ありますか?
0 1 0 2 0 1 0 3 0 1 0 2 0 1 0 4 ...
というのが欲しいです。

>>751
とりあえず意味不明

数学的に解くのが簡単そうだが、
ビット演算で解きたいんだろうな・・

1 001 0
2 010 1
3 011 0
4 100 2
5 101 0
6 110 1
左が十進、真ん中が二進、右が二進表現で立っている最右ビットの位置です。
なにかいい方法がありそうな気がするんですが。

>>151
単純に数えればいいんじゃないの？

一番左のビット位置を知るには　>>7

それをカウントする方法は>>277


もっと効率いい方法が無いかという事？　表を作るんだから、それほど効率は上がらないだろう

ごめん >>377 だった

>>755
表を作るというかその場でつかいたいんですよね。
表を作るんならエラトステネスのふるいみたいなかんじで2のべき乗のところをインクリメント
していけばできそうですけどね。

元のコードが

for(i = 1; i < (1 << 16); i++){
func(ffs(i));
}
みたいな感じで、ちょっと改良したのが

func(0);
func(1);
func(0);
for(i = 1; i < (1 << 16) >> 2; i++){
func(ffs(i) + 2);
func(0);
func(1);
func(0);
}
みたいな感じです。

ffsはいろいろ試して
unsigned ffs(unsigned n){
n = (~n & (n - 1));

n = n - ((n >> 1) & 0x5555);
n = (n & 0x3333) + ((n >> 2) & 0x3333);
n = (n + (n >> 4)) & 0x0F0F;
n = n + (n >> 8);
return n & 0x1F;
}
としています(高々16ビットなので)。

インクリメントしていくんなら ffsを呼ばないでできないかなあ
と思っているんですが無理でしょうか?

>>757
使い道は何？　その逆にMSBの位置を知るのは浮動小数点化なんかで必要になるのは判るのだけど

memsetにベリファイ機能をもつ関数を作成したいと思ってます。
しかも、それをmemsetよりも速い、もしくは近いレベルまでにしたいと思ってます。

何かよい方法はありますか？

>>759
学校の宿題でブロック符号の符号語の重み分布を求めるプログラムを書くというやつでして
ハミング距離が1の符号を辿っていくときにグレイコードの反転するビットの位置がこれなんです。
nビット目が反転する時は生成行列の下からn行目を足すという感じで 2^16-1回足すと
2^16個ある符号を全て得ることができるんです。

別に高速化する必要はないんですが、かっこいいやりかたがあるんじゃないかっていう好奇心です。

16bitの範囲で順にfuncに引数として渡すだけでいいのなら
再帰的にスタックを16段使って出力すればいいんじゃないの？

>>760
具体的に目的を提示しないと答えが出ないと思うよ。
つーか、制御系スレ向きかな。

>>762
どういうやり方なんでしょうか？
コルーチンぽいのがあればできる予感はするんですが。

>>760
ちょっと理屈で考えてみろ

メモリーに書き込むにはサイクルが必要だ
メモリーから読み込むにもサイクルが必要だ。

両方をやろうと欲張ってるのに、片方だけやってるのと同じコストで出来る筈がない。

ようはmemset(address, 0x35, sizeof(address));
として仮に1024バイト分0x35を書き込んだと仮定します。
その際に本当に0x35で書き込まれたのかをチェックしたいのです。
そのチェック方法と、さらに
１．書き込みながら随時チェック
２．すべてのデータを書き込んだ後全部チェック
のどちらが速いかなどです。

ＣＰＵのキャッシュについてどう思う？

"１．書き込みながら随時チェック "
ではキャッシュのエラーを検出出来ないので、
"２．すべてのデータを書き込んだ後全部チェック"
が正解。

なんてね

それでもキャッシュに収まってたら(ry

ヴェリファイに失敗したらどうすわけ？

チェックする暇があったら、もう一回書き込め。
　

>>764
再帰的に書けばいいという事
最初に 0 0x10000 16 16 の４つを渡して

先頭で最後の引き数を１減らす 16->15...0と
　　これが０になったら2番目を出力して終わり
　　でなければ、自分自身を2度呼び出す
　１番目は　0+,0x10000/2,16,15
　２番目は　0+0x10000/2,0x10000/2,15,15

結果、最後の引き数が０の時は、1番目の引き数は2進数を順を刻むことになり３番目の引数が目的

#include <stdio.h>
void doit(int i)
{ printf("%d\n", i);}
template<int N> void FFS()
{ FFS<N-1>(); doit(N); FFS<N-1>();}
template<> void FFS<2>( )
{ doit(0); doit(1); doit(0); doit(2); doit(0); doit(1); doit(0);}
int main()
{ FFS<16>();}

ビット演算関係ないけど(w

>>773　ただ繰り返すだけのように見えるのがミソなのか？

ただ繰り返す？

スマン　doit(N);　を見損なった。
しかし、逆アセンブルした奴は目を剥くだろうな

>>772
よく分からないんですが、それは条件分岐をたくさんするんでしょうか?
だったら ffsと変わらない気がします。

>>777
条件分岐が嫌なら、同じような関数を16個ほど書いてネストすればいい
それでも >>773よりマシだ

テンプレート嫌い？

それから773のように工夫すれば段数はそれだけ減らせる
また、ネスト深さの引き数はいらない
1番目2番目の引き数も、何の数かが必要なければいらない。
つまり引き数は一つでいい

つまりはこういうこと。
void dispffs( int level){
if( level == 2 ) { doit(0); doit(1); doit(0); doit(2); doit(0); doit(1); doit(0); return;}
dispffs( level-1); doit( level ); dispffs( level-1);
}

>>781
おお、できました。深さは高々16だし、幅が2^16-1ってだけで負担にはならないですね。
再帰で解くという発想がありませんでした。やりたかったこととは違うんですが、これは美しいですね。
関数呼び出しのコストとか考えると微妙なのかもしれませんが。
ただ if(level == 0) doit(0) でいいですよね。

すいません。少しでも段数減らすためってことですね。
実際に速度を測ったら普通に ffs呼んだ方が速かったので悲しかったです。
自分でスタック用意すれば速くなるかもしれませんね。

一応スタック自前バージョンを書いておきます。ビット演算関係なくてすいません。

unsigned Stack[16];
unsigned *SP = Stack + 1;

void comp(unsigned n){
for(;;){
if(n == 0){
func(0);

n = *--SP;
if(n == 0) return;
}
else {
*SP++ = n;
--n; continue;
}

func(n);
--n;
}
}

つうかffs(3)て大抵そのアーキテクチャに最適化されてるから、
Cで書いて、より速いのはなかなか作れんだろう。

巨大テーブル使うんなら別だが。

なんかおかしかったのでもう一度。

>>758
たしかにそうですね。>>758より速かったです。
インラインアセンブラで bsf使って書いたらすごい遅かったんですけどね。
/usr/src/lib/libc/string/ffs.c は普通のCのコードだしソースがどこにあるのか
分からない...
0チェックしなくていいからもっと高速にかけるかもしれないんですけどね。

void comp(unsigned n){
for(;;){
if(n == 0){
func(0);

n = *--SP;
if(n == 0) return;
func(n);
}
else {
*SP++ = n;
}
--n;
}
}

速度があまりに違うようだと計測方法それ自体を見直した方が・・
最適化でコードがばっさりなくなってたりとか。

>>786
ここらかね。
http://cvsweb.netbsd.org/bsdweb.cgi/src/common/lib/libc/arch/i386/string/ffs.S?rev=1.1

というか、bsfだな

1.
*address = data;
address++;
*address = data;
address++;
*address = data;
address++;
*address = data;
address++;

と

2.
address[0] = data;
address[1] = data;
address[2] = data;
address[3] = data;
address += 4;

の処理があったとして、これをループ処理を行った場合、1と2ではどちらが速いでしょうか？

memcpy系統はそもそもメモリが遅すぎるので
64bitまとめて〜とか、アラインメントを〜とかを考えないと、
CPU側に多少無駄があっても変わらない。

最適化スレじゃないんだが・・・・・

>>790 基本的にコンパイラと環境による
話題のSHでは　
下の場合は効率の良いアドレッシングモードがあるので速いかもしれないし
上の方が巧く命令が馬って速いかもしれないし

パソコンのＣＰＵならメモリアクセスに隠れてしまうし

という事で、どっちが速いか判らん

*++address=*++address=*++address=*address=data;
最適化支援

>>786
ヘッダに

#ifdef __GNUC__
#define ffs __builtin_ffs

の類があったりしないか?

ところで、遅くなった bsf の淫乱アセンブラの表記に興味がある。

>>794
strings.h にも ffs.cにも書いてありませんが、
/usr/src/lib/libc/arch/i386/string/ffs.Sに >>788と同じファイルが
ありました(NetBSDです)。
インラインアセンブラは
asm("ffs2:");
asm("bsfl 4(%esp), %eax");
asm("ret");
って書いただけです。
ffsは-O2以上で
xorl %eax, %eax
bsfl %ecx, %edx
sete %al
negl %eax
orl %eax, %edx
incl %edx
というのが埋めこまれていました。ffs2は
pushl %ebx
call ffs2
movl %ebx, (%esp)
となっていました。他にもGCCの最適化が頭良すぎてちゃんと計れてないっぽいです。
副作用を起こさない、とか引数一緒なら返り値一緒ってどうやって判断してるんでしょうか?

>>795
GCC on NetBSD/x86だったら以下のサンプルをコンパイルしてみそ。

int f(unsigned a)
{
return __builtin_ffs(a);
}

int b(unsigned a)
{
int r;
asm("bsfl %1,%0": "=r"(r): "g"(a));
return r;
}

インラインアセンブラの使い方がよくない。
gcc asm constraint でぐぐれ。

>>796
インライン展開されるようになりました。
オリジナルの ffsより若干速いって感じです。

この改良ffsを >>757の下のコードで使うと >>786をちょっと改良したやつより速かったです。
そしてテーブル使うよりも速かったです。

僕がイメージしていたのは変数二つをループでいじくりまわして
0 1 0 2 0 1 0 3 という結果を得るという感じだったんですけど
bsfがあるならそれを使った方がよさそうですね。
移植性考えるなら ffs(i) - 1を使ってもいいと思うんですが
インライン展開されて
incl %eax
decl %eax
となっていて萎えました。

色々試しましたところ、
メモリをクリア＆確認する際に

１．
アドレスに0をセット
0になってるかORしてチェック
アドレスを加算
以下サイズ分ループ

２．
アドレス＋サイズを算出（終了アドレス＋１）

アドレスを減算
アドレスに0をセット
0になってるかORしてチェック
以下サイズ分ループ

1と2で、やってることは似たようなもののはずなのに（ただ単にアドレスを加算してるか減算しているかの違いぐらい）
なぜか処理速度（サイクル数）が異なってました。

原因として何が考えられますか？

スレ違い。

>>798
アセンブリ出力を見て調べろ。

dec eax
jnz loop
と
inc eax
cmd eax,ecx
jne loop
のちがいじゃねーの

↓反応した奴は池沼

あびゃっばばばぁばばあ

あげ

>798
ようはパイプラインの問題だけだと思う

ベンチャーズの季節か。

あげ

(1 << 7) << 3

1<<(7+3)

2^7 x 2^3 = 2^(7+3)

ハッカーのたのしみ―本物のプログラマはいかにして問題を解くか
ttp://www.amazon.co.jp/exec/obidos/ASIN/4434046683

この本を読めるようになるには数学以外でどの程度の知識が必要でしょうか？

>>811
その書籍が記述されている言語の基本知識は最低限必要です
例:日本語
あかいさくらのはながさいた

2^7^7 の 1 桁目の数字は？

0

2^7^7 の 1 桁目の数字は？

まちがえた
ごめん

7^7^7 の 1 桁目の数字は？

>>816
最下位ビットを聞いているのなら1だ。
a^aは常に0だから、簡単にわかる。

べき乗？

7

ここで聞いてるんだから、やっぱりXOR演算子なんでしょう。

質問の意図がわからんから適当に答えてるんだと思うが？

まじめに答えてもらおうと思ってないから適当に質問されているのだと思うが？

誰か >>821 の文章に主語を補完してくれないか。俺は良く分かんなかった。

つまりネタがありません
と翻訳してみたが

(((( ；ﾟДﾟ)))ｶﾞｸｶﾞｸﾌﾞﾙﾌﾞﾙ2005年度入社278人目
http://money4.2ch.net/test/read.cgi/employee/1151055613/

(((( ；ﾟДﾟ)))ｶﾞｸｶﾞｸﾌﾞﾙﾌﾞﾙ2005年度入社278人目
http://money4.2ch.net/test/read.cgi/employee/1151055613/

(((( ；ﾟДﾟ)))ｶﾞｸｶﾞｸﾌﾞﾙﾌﾞﾙ2005年度入社278人目
http://money4.2ch.net/test/read.cgi/employee/1151055613/

(((( ；ﾟДﾟ)))ｶﾞｸｶﾞｸﾌﾞﾙﾌﾞﾙ2005年度入社278人目
http://money4.2ch.net/test/read.cgi/employee/1151055613/

もっと議論したまえ。

しょうがねぇな
n x nの正方pixelのfontデータを90度回転させる
効率のよい処理方式でも考えてみれ

シフトとキャリー使って良いですか

>>826
n=16用だがfontx[]に16x16のbitmapが格納されているとして
fonty[]に90度左回転したビットマップを格納する処理w

unsigned short fontx[16],fonty[16];

#define ROT(var,x,y) (0!=((var)[(x)] & (1 << (y))))<<(x)
#define ROT1616(to,fr,x) (to)[(x)]= \
　　ROT((fr),15,15-(x))|ROT((fr),14,15-(x))|ROT((fr),13,15-(x))|ROT((fr),12,15-(x))|\
　　ROT((fr),11,15-(x))|ROT((fr),10,15-(x))|ROT((fr), 9,15-(x))|ROT((fr), 8,15-(x))|\
　　ROT((fr), 7,15-(x))|ROT((fr), 6,15-(x))|ROT((fr), 5,15-(x))|ROT((fr), 4,15-(x))|\
　　ROT((fr), 3,15-(x))|ROT((fr), 2,15-(x))|ROT((fr), 1,15-(x))|ROT((fr), 0,15-(x))
:
　　ROT1616(fonty, fontx, 0); ROT1616(fonty, fontx, 1);
　　ROT1616(fonty, fontx, 2); ROT1616(fonty, fontx, 3);
　　ROT1616(fonty, fontx, 4); ROT1616(fonty, fontx, 5);
　　ROT1616(fonty, fontx, 6); ROT1616(fonty, fontx, 7);
　　ROT1616(fonty, fontx, 8); ROT1616(fonty, fontx, 9);
　　ROT1616(fonty, fontx,10); ROT1616(fonty, fontx,11);
　　ROT1616(fonty, fontx,12); ROT1616(fonty, fontx,13);
　　ROT1616(fonty, fontx,14); ROT1616(fonty, fontx,15);

漏れら極悪非道のageブラザーズ！
今日もネタもないのにageてやるからな！
￣￣∨￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣
　 ∧＿∧ 　 ∧＿∧ 　　　age
　（・∀・∩）（∩・∀・）　　　　age
　（つ　　丿 （ 　　⊂）　age
　 （　ヽノ　　 ヽ/　　）　　　age
　 し（＿）　　 （＿）Ｊ

数値をレジスタに代入するときにPUSH、POP命令で代入した方がいいのはなぜですか？

どのプロセッサの話だよｗ

>>831
すまん
x86です

任意の桁数の2進数をを簡単に素早く反転（？）させる方法はありませんか？

こんな感じの反転

110100
　↓
001011

POP命令で可能と思うが、PUSHはねえぞ

>>833はまちがい

10011
　↓
11001


こんな感じの最上位から最下位ビットの並びを
最下位から最上位へ変換ということです

fftか？

2のべき乗でビット転置やって 右シフトすれば良くないですか？
5bitなら8bitで十分ですな

n = (n << 4) & 0xF0 | (n >> 4) & 0x0F;
n = (n << 2) & 0xCC | (n >> 2) & 0x33;
n = (n << 1) & 0xAA | (n >> 1) & 0x55;
n >>= 3;



あんまりビット数が多い場合はbyteレベルならbswapとかシャッフル命令とかを使って、
バイト単位の反転を行っておいてからやると高速化できるかと思われます

>>837
ダンゴきたあああああああああああああああああああああああああ

n = ((n << 4) & 0xF0) | ((n >> 4) & 0x0F);
n = ((n << 2) & 0xCC) | ((n >> 2) & 0x33);
n = ((n << 1) & 0xAA) | ((n >> 1) & 0x55);
n >>= 3;

演算子の評価順位が不安なので修正

ダンゴさんありがとお

char bitrev[] = {
0x00, 0x80, 0x40, 0xC0, ....
};
って、テーブル作っとく。

最近のコンパイラって、>841みたいなのをxlat使うのかなぁ。
尤も、そもそも最近のCPUでxlatが速いかどうかが問題だけど。

>>839, >>841, 4bitや2bitに切ってswitch

switch(n&0xf){
case 0x0:H=0x00;break;
case 0x1:H=0x80;break;
...
}
switch(n&0xf0){
case 0x00:L=0x0;break;
case 0x10:L=0x8;break;
...
}
return H|L;

の4パターンを関数にしてざっと測ってみたところ、時間的にはどれも同じだった。
関数コールのオーバーヘッドで埋まる程度の処理って事だ。
なので素直に>>839でおk

>839よりは>841の方が素直だと思う漏れもいる。

>>844
ビット数が増えるとテーブルじゃ苦しいんだよね

32bitなら
n = (n << 16) | (n >> 16);
n = ((n << 8) & 0xFF00FF00) | ((n >> 8) & 0x00FF00FF);
n = ((n << 4) & 0xF0F0F0F0) | ((n >> 4) & 0x0F0F0F0F);
n = ((n << 2) & 0xCCCCCCCC) | ((n >> 2) & 0x33333333);
n = ((n << 1) & 0xAAAAAAAA) | ((n >> 1) & 0x55555555);



VC2005使う限りでは組み込みのbswap使うほうが速かった
n = _bswap( n );
n = ((n << 4) & 0xF0F0F0F0) | ((n >> 4) & 0x0F0F0F0F);
n = ((n << 2) & 0xCCCCCCCC) | ((n >> 2) & 0x33333333);
n = ((n << 1) & 0xAAAAAAAA) | ((n >> 1) & 0x55555555);

さて、上司からアホなことを言われた俺がやってきましたよ。
なんでもmemsetやmemcpyやmemmoveなどを改良して高速動作するように
作れとのこと。何かしらサンプルはありますか？
そもそも標準関数であるmem系を改良する価値はあるのか？

>>846
つ memcpy_amd

そのへんはVCなら最適化すれば組み込みの命令に展開されるのであんまり意味はないかと

一番有効と思われるのがMMX/SSEを使う方法ですな。
ビット演算云々よりアセンブラとかSIMD関連になります


ただ、キャッシュ内でこね回すだけならともかく、メインメモリからの読み書きなら
FSBで律速されるのであんまり意味は薄いです

NomisoBraaanにいくつかリンクがあるよ。

VCの組み込みmemcpyは遅い。
しかし、よしんば速くなったところで2〜3倍速なので
劇的に速くなるとも思えない。

まだボトルネックを確認してなければプロファイルが先。

私としたことが環境を書いてないですね。
用途はシーケンサ制御です。
そのため、あるバッファからあるバッファへメモリ展開などを行う際に
高速化する必要があるらしいのです。

CPUはSH-3というものを使っています。
コンパイラはSHの純正であるSHCの最新版です。

正直、じゃあ上司が作れば？と思うのですがいえない今日この頃。
でもある意味ここで聞く内容ではない気もしてきました。
聞くとしたら組み込み系？それともC言語系ですかね？

ここで聞いた理由はここの人たちはレベルが高いような気がしましたので

864ではなく846でした

sh3で作るならMAとIFをぶつからないようにして、
あとは素直にalignmentで場合分けして最適化すれば十分速くなる。

>>851
どこがビット演算なのかと。で、本当にボトルネックがmemcpy()なのかどうかの確認はすること。
「メモリ展開」処理そのものが遅かったら転送速度を上げても無駄だぞ。

>>851
SH4をSHCでやってる仲間ｗだが、
ちょっといいたいことがある。


上司をここに呼べｗｗｗ


つーかビット演算と関係ネーシ。

ここで聞いたのは
＞ここで聞いた理由はここの人たちはレベルが高いような気がしましたので
だからじゃねーの？

何を持ってレベルが高いのかは不明だが

確かにアセンブラスレや制御系スレよりここの方が賑やかだけどねぇ。

んで結論は「わかりません」かｗ
まあ846もここで聞くのがお門違いってこと。

こんな場所で>>846のような質問しちゃうアホが部下なら>>846みたいな
アホな事やらせてみるのもありだと思う。

>>845
バイト単位ならエンディアン変換関数があるんだから、それをかけた後に各バイトにビット反転かければいいじゃん。

>>860
1の補数？

ttp://homepage1.nifty.com/herumi/adv/bbslog/bbs10.html
ここの493。

x86なら、leaやbswapが使えておいしい。

>>862
いや、2個目はそれと全く同じことやってますが。
VC2005の_bswap()はそのまんまbswapに展開されますぜ

>>863
いや、単に解説投下しただけで、他意はないです。

; アルゴリズムオタク スレから誘導されてやってきました．

x が与えられたとき，2^(a+1) > x ≧ 2^a となる 2^a を高速に(ループ等を使わ
ず，できればビット演算のみで)求める方法を探しているのですが，そういうア
ルゴリズムご存じの方いらっしゃらないでしょうか？
言語は C です．

よろしくお願いします．

2進数で表現したときに、最下位ビットを0番としてa番目だけが1になる数です

答書いちゃうけど
unsigned int flp32(unsigned int x) {
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x - (x >> 1);
}


機種依存の方法を使うなら、組み込みのビットスキャンを使うなり、
浮動小数にキャストしてSIMDレジスタ上でごにょごにょ（ｒｙ

>>866
有り難うございます．元スレでもどうようの答えをいただけました．

>浮動小数にキャストしてSIMDレジスタ上でごにょごにょ（ｒｙ

指数部を取り出すということだと思ったのですが，ここで SIMD レジスタが出
てくるのは何ででしょうか？よろしければご教授ください．

特に意味はないが、SSEならビットマスク演算が使えるから。
仮数部に相当する23bitをマスクしてゼロクリアしてしまってから整数に戻す手もある。

>>868
有り難うございます．元スレでもどうようの答えをいただけました．

x86 なら　BSR　命令で a を出すだろな

DSPとかにも、BSRのような命令はある。
浮動小数点への変換とか圧縮とかに便利だから。

でもBSRって書くと、どうもサブルーチンコール命令に勘違いしてしまうから嫌だな

あげ

>>835, 836
一連の反転値数列が欲しい場合は、

///////////////////////////////
n = 1 << 5;
j_rev[0] = 0;
i=0;
for( j=1; j < n-1; j++ ){
for( k=n>>1; k > (i^=k); k>>=1 );
j_rev[j] = i;
}
j_rev[n-1] = n-1;
//////////////////////////////////

これで、j_rev[b10011] = b11001
のようになります。
今日、fft の勉強しててやり方を知りました。

オセロの盤面を白黒２つの64ビット整数で表して（bitboard）、
黒石の打てる箇所をビット演算で求めたいのですが、どうしたらいいですか？

白も黒もビットが立っている事はありえないなら空いてる場所はxorで0のビット
ルールに則って打てる場所なら�_

http://www.radagast.se/othello/bitmob.c

↑にZebraのソースコードが公開されているのですが、何がなにやらよくわりません

黒石を打って、右方向に白石を1個だけ返せるのは、空白黒 というパターンなので、
黒石のbitboardを black_board, 白石のを white_board とすれば、以下のようになる

blank = ~(black_board | white_board); // 空白の箇所
t = (blank >> 1) & white_board & 0x7f7f7f7f7f7f7f7f; // 空白 のパターン
t = (t >> 1) & black_board & 0x7f7f7f7f7f7f7f7f; // 空白黒 のパターン
mobility = t << 2; // 右方向に1個返せる箇所

これであってる？

右方向に打てる場所のビットを探すのであれば、右の黒石からスタートした方が、最後のシフトが不要になる。

t = (black_board << 1) & white_board & 0xfefefefefefefefe; // 白黒 のパターン
blank = ~(black_board | white_board); // 空白の箇所
mobility = blank & (t << 1) & 0xfefefefefefefefe; // 右方向に1個返せる箇所

コードを見やすくするために左移動を
inline uint64 move_left(b) { return (b<<1)&0xfefefefefefefefe; }
と定義しておく。
1方向に返る石の数は最大6個なので、右方向の処理は以下のようになる

t1 = white & move_left(black); // 白黒 のパターン
t2 = white & move_left(t1); // 白白黒 のパターン
t3 = white & move_left(t2); // 白白白黒 のパターン
t4 = white & move_left(t3); // 白白白白黒 のパターン
t5 = white & move_left(t4); // 白白白白白黒 のパターン
t6 = white & move_left(t5); // 白白白白白白黒 のパターン
blank = ~(black | white); // 空白の箇所
mobility = blank & move_left(t1 | t2 | t3 | t4 | t5 | t6); // 右方向に返せる箇所

あとはこれを残りの7方向についてやればおけ？

w = white & 0x7e7e7e7e7e7e7e7e;
t = w & (black << 1);
t |= w & (t << 1);
t |= w & (t << 1);
t |= w & (t << 1);
t |= w & (t << 1);
t |= w & (t << 1);
blank = ~(black | white); // 空白の箇所
mobility = blank & (t << 1);

もうちょっとすっきりしたかな？
合ってる？

すばらしい>>879

>>878 と比べると
・ 論理積演算が1回で済んでいる
・ 使用する変数の数が減っているので、アセンブラにするときに都合がよい
・ 0x7e...7e と 論理積をとっているので、逆方向の処理についてもこの結果が使用できる
というアドバンテージがある

念のために、8ビットの全パターンについてプログラムを組んで動作を確認してみたところ、
878 と 879 は同じ結果を返した。
なので、879 は合ってるようだ

着手可能箇所のリストアップはできたので、今度は指定場所に黒石をおいたときに、
白石を反転させて、盤面を更新したい。
どう書いたらいい？

打つ場所は、Bitboard で表したときに１が立っているビットの位置（0..63）で指定するものとする。
int pos;
これをbitboradパターンに変換するために Bitboard set_mask[64] という変換テーブルが既に
用意されているものとする

先読みの処理は、以下のような感じに書ける

Bitboard mobility = getMobility(black, white); // すべての着手可能箇所を取得
while( mobility != 0 ) {
　int pos = getFirstOne(mobility); // ビット値が１の一番下の位置を返す
　Bitboard rev = getRevBlack(black, white, pos); // pos に黒石を打ったときに反転する白のパターンを取得
　Bitboard m = (1<<pos); // 着手位置のビットパターン
　black |= m | rev; // 黒石を更新
　white ^= reb; // 白石を更新
　// なんらかの処理
　black ^= m | rev; // 黒石を元に戻す
　white ^= reb; // 白石を元に戻す
　mobility ^= m;
}

ビット演算で、それが意図通りに動く事を証明する道具的な学問はなんですか？

[華麗にスルー]


　　　　　　三三三　>>883
　　　　　　　　　　　　　　　　　　　　三三三　>>883
　　　　　　　　 ＿ ∩
　　　　　 ⊂／　　ノ　）　　　　　　　　　　　　　三三三　>>883
　　　　　　/　　　/ノﾉﾉ　　　　　三三三　>>883
　　　　　　し'⌒∪

ブール代数、論理学 かな？
と答えてみる

Bitboard m に黒石を打ったときに、反転する白石のパターンを取得する処理
まずは１方向のみ＆ループを使ったコード：（m に着手可能なのは次善にチェック済みとする）

Bitboard rev = 0;
Bitboard mask = m;
for(;;) {
　mask >>= 1;
　if( (mask & black) != 0 ) break;
　rev |= mask;
}

さあ、ループを無くすことができるか？

おおっと、その方向に着手可能かどうかは保障されてないので、
>>886 のコードではまずいぞ

着手可能箇所を調べるときに、8方向について計算し、その論理和をとるわけだが、
それぞれの方向の値を保持しておけば、特定の方向に返るかどうかがわかる。
そうであれば、>>886 のコードでも大丈夫だ

>>879 と >>878 が何故同じ結果を返すのかよくわからなかったけど、
シフトと論理和が分配法則をみたし、論理和が重複法則を満たすからなんだね

(x | y) << 1 == (x << 1) | (y << 1) // 分配法則
x | y | y == x | y // 重複法則

8x8 のビットパターンが32ビットレジスタに入っているとき、
これを高速に90度回転するにはどうしたらいいんですか？

ごめん、32ビットレジスタには8x8は入りきらない

32ビットレジスタ２つ、または64ビットレジスタに入っているものとします

Σ (ﾟДﾟ;）

>>890
首を９０度曲げる

100年に一度の鬼才

>>893-894
少々馬鹿な方法でやろうが、CPUがその程度の処理をこなす速度に
人間が首を曲げる速度で対抗できるわけがなかろうが。

SSEが使えるならpsllq & pmovmskb使うのが一番速そうだけど

とりあえず汎用性のあるのは

uint64 a[256] ;
memset(a, 0, sizeof(a);
for ( int i = 0; i < 256; i++ ) for ( int j = 0; j < 8; j++ ) a[i] += (i & (1 << j)) << (7 * j);

//↑ここまではあらかじめ計算しておく

reg = a[reg & 0xFF] | (a[(reg >> 8) & 0xFF] << 1) | (a[(reg >> 16) & 0xFF] << 2)
| (a[(reg >> 24) & 0xFF] << 3) | (a[(reg >> 32) & 0xFF] << 4) | (a[(reg >> 40) & 0xFF] << 5)
| (a[(reg >> 48) & 0xFF] << 6)| (a[reg >> 56] << 7);

>>890
一応、ハッカーの楽しみを読めば乗っているよ。

typedef unsigned long long ulong;
ulong rotate(ulong x){
    x =
        x << 1 & 0xAA00AA00AA00AA00ULL |
        x >> 1 & 0x0055005500550055ULL |
        x >> 8 & 0x00AA00AA00AA00AAULL |
        x << 8 & 0x5500550055005500ULL ;
    
    x =
        x << 2 & 0xCCCC0000CCCC0000ULL |
        x >> 2 & 0x0000333300003333ULL |
        x >> 16& 0x0000CCCC0000CCCCULL |
        x << 16& 0x3333000033330000ULL ; 
    
    x =
        x << 4 & 0xF0F0F0F000000000ULL |
        x >> 4 & 0x000000000F0F0F0FULL |
        x >>32 & 0x00000000F0F0F0F0ULL |
        x <<32 & 0x0F0F0F0F00000000ULL ;
    return x;
}

memset(a, 0, sizeof(a) );

と。。。

論理和・論理積・シフト演算の優先順位ってどうだったっけ？

>>898
シフト演算は、加減算のすぐ下、各種論理演算よりは上。

論理和と論理積では論理積の優先順位が高い。
通常の和と積では、積の優先順位が高いのと同じ。

優先度の高い順に並べるとこう >> , & , |

論理積と論理和の優先順位の並びは算数の積と和の優先順位と同じ並びかたで、
なおかつシフトより優先度が低い。
自分はこの辺体にしみついちゃってるから結構（）は省きがち。

>>897
何で、これで回転できるの？
さぱーりわからん

>>901
分割統治方をつかってますです。

最初は2*2の回転。
次は4*4の回転。既に4*4の中身の2*2の回転は済んでいるので外側だけの回転。
最後は8*8の回転。既に8*8の中身の4*4の回転は済んでいるので外側だけの回転。

とりあえず、下は4*4だけどこんな感じに回転する。
１２３４
５６７８
ＡＢＣＤ
ＥＦＧＨ
 ↓2*2の回転
２６４８
１５３７
ＢＦＤＨ
ＡＥＣＧ
 ↓4*4の回転
４８ＤＨ
３７ＣＧ
２６ＢＦ
１５ＡＥ

>>897
転置してバイトオーダを入れ替える方が速くないかい？

uint64 rotLeft90(uint64 x)
{
uint64 t = ((x >> 7) ^ x) & 0x00aa00aa00aa00aa;
x = x ^ t ^ (t << 7);
t = ((x >> 14) ^ x) & 0x0000cccc0000cccc;
x = x ^ t ^ (t << 14);
t = ((x >> 28) ^ x) & 0x00000000f0f0f0f0;
x = x ^ t ^ (t << 28);
return byteSwap(x);
}

こっちは (シフト演算*2 + 論理演算*4) * 3 + byteSwap
byteSwap は x86 の bswap を使えば4命令でできる

>>897 は (シフト演算*4 + 論理演算*7) * 3

実際にプログラムを書いて、回転関数を1億回コールした場合の時間を計測してみた
＠Athlon 64 2.0GHz

>>897 は 5.55秒
>>903 は 3.45秒 （byteSwap() の部分を __asm で記述した）

>>896 は、そのままだとコンパイルエラーになる
memset の閉じカッコが抜けている

しかも、テストプログラムを実行すると正しい値を返さなかった

>>896 は正しい値を返さないが、とりあえず実行速度を計ってみた

2.53秒/1億回ループ

デバッグすると遅くなるかもしれんが、今は速いぞ

テーブルを使う版を書いてみた。テストプログラムで動作確認済み

static uint64 g_rotTable[256];
void setup_rotTable()
{
//ix のビットパターンを左回転させたものを g_rotTable[ix] に格納
for(int ix = 0; ix < 256; ++ix) {
uint64 v = 0;
uint64 vm = 0x0100000000000000;
for(int mask = 1; mask < 0x100; mask <<= 1, vm >>= 8) {
if( (ix & mask) != 0 )
v |= vm;
}
g_rotTable[ix] = v;
}
}
uint64 rotLeft90_table(uint64 x)
{
uint64 t = g_rotTable[x & 0xff];
t |= (g_rotTable[(x >> 8) & 0xff] << 1);
t |= (g_rotTable[(x >> 16) & 0xff] << 2);
t |= (g_rotTable[(x >> 24) & 0xff] << 3);
t |= (g_rotTable[(x >> 32) & 0xff] << 4);
t |= (g_rotTable[(x >> 40) & 0xff] << 5);
t |= (g_rotTable[(x >> 48) & 0xff] << 6);
t |= (g_rotTable[(x >> 56) & 0xff] << 7);
return t;
}

んで、1億回ループさせて時間を計測すると

5.09秒

>>903 より全然遅い
それぞれの演算数を比べると以下のとおりだ

>>907 : 5.09秒 シフト演算 * 14 + 論理演算 * 15 + 配列によるメモリアクセス * 8
>>897 : 5.55秒 シフト演算 * 12 + 論理演算 * 21
>>903 : 3.45秒 シフト演算 * 6 + 論理演算 * 12 + byteSwap (アセンブラ4命令）

>>907 のコードだとメモリは食うし遅いしで、いいこと無いね

>>896 に書いてある「汎用性のある」とはどういう意味だ？

団子の妄言は気にすんな

>>895
相当広い面積になった場合は首を曲げるほうが早いけどな

>>909 了解

ところで、時間計測は Athlon 64 2.0Ghz WinXP VC6 32ビットモードで計測している
VC6 の __int64 のシフト演算はサブルーチンコールになるので、非常に遅い
Athlon 64 の64ビットモードでコンパイルするとかなり高速になりそうだ

それと >>907 のコードはシフト処理を減らせばもっと高速になるはず

64ビットシフトをほとんど無くしてみた

uint64 rotLeft90_table(uint64 x)
{
uint32 hi = (uint32)(x >> 32);
uint32 low = (uint32)x;
uint64 t =g_rotTable[(uchar)(hi >> 24)];
t = t + t | g_rotTable[(uchar)(hi >> 16)];
t = t + t | g_rotTable[(uchar)(hi >> 8)];
t = t + t | g_rotTable[(uchar)hi];
t = t + t | g_rotTable[(uchar)(x >> 24)];
t = t + t | g_rotTable[(uchar)(x >> 16)];
t = t + t | g_rotTable[(uchar)(x >> 8)];
t = t + t | g_rotTable[(uchar)x];
return t;
}

しかし、処理時間は 6.69秒/1億回ループ と逆に増えてしまった。
何故だろう？

結局テーブルを用いる方法はテーブルアクセスが頻繁になりバス幅を使い切ってしまうので
よろしくない、ということなのかなぁ

64ビットシフトならInt64ShrlMod32とかはどう？
ヘッダ見る限り、インラインアセンブリで書いているようだけど。

> SSEが使えるならpsllq & pmovmskb使うのが一番速そうだけど
妄言のような気もするが、念のために MMX を使用した版も作ってみた。
アルゴリズムは最速の 転置を行って、バイトスワップをするのを使用
処理時間は 3.16秒/1億回ループ と期待したほどには高速化されなかった

uint64 rotLeft90_MMX(uint64 x)
{
__asm {
movq mm0, x

movq mm2, td_00aa00aa00aa00aa
movq mm1, mm0
psrlq mm1, 7
pxor mm1, mm0
pand mm1, mm2
pxor mm0, mm1
psllq mm1, 7
pxor mm0, mm1

=== 長いので省略 ===

movq x, mm0
mov edx, long ptr x ; 上下32ビット反転
mov eax, (long ptr x) + 4
bswap edx
bswap eax
}
}

ulong
r (ulong x)
{
unsigned int a, b, c, d;
unsigned int y[2];

asm volatile ("movq %0, %%mm0" : : "m" (x));
asm volatile ("pmovmskb %%mm0, %0" : "=g" (a) :);
asm volatile ("psllq $1, %mm0");
asm volatile ("pmovmskb %%mm0, %0" : "=g" (b) :);
asm volatile ("psllq $1, %mm0");
asm volatile ("pmovmskb %%mm0, %0" : "=g" (c) :);
asm volatile ("psllq $1, %mm0");
asm volatile ("pmovmskb %%mm0, %0" : "=g" (d) :);
y[0] = a | (b << 8) | (c << 16) | (d << 24);
asm volatile ("psllq $1, %mm0");
asm volatile ("pmovmskb %%mm0, %0" : "=g" (a) :);
asm volatile ("psllq $1, %mm0");
asm volatile ("pmovmskb %%mm0, %0" : "=g" (b) :);
asm volatile ("psllq $1, %mm0");
asm volatile ("pmovmskb %%mm0, %0" : "=g" (c) :);
asm volatile ("psllq $1, %mm0");
asm volatile ("pmovmskb %%mm0, %0" : "=g" (d) :);
y[1] = a | (b << 8) | (c << 16) | (d << 24);

return y[0] | ((ulong) y[1] << 32);
}
pmovmskb使ったのってこういうのだと思ったけどコンパイラの最適化にかなりたよった
これより速いの書けなかった
ちなみに>>897のが5.96秒でこれが3.41秒だった

ビット演算で使えるのは、
and, or, xor (not)
right shift, left shift
ほかにある？ローテートとかもOK?
一応、addやmulとかもビットの演算にすぎないんだけど・・

ううう、VC6 __asm では pmovmskb がサポートされていないみたいだ ＿|￣|○

>>916 すべての演算はビット演算だ
ただし、mul や div は論理演算に比べると実行速度が遅いので、
それを補って余りあるメリットがなければ使用しない方がよろし

>>915
1ビット左シフトはユニットの空きを考慮して適宜同一レジスタ間の加算で代用するのは常識
あと、SIMD整数ユニットは大概2本あり、AMDのSIMDはLatencyが大きいのでその辺も考慮されたい。

movq mm0, mmword ptr [src]
pmovmskb eax, mm0
mov byte ptr [dest + 7], eax
movq mm1, mm0
paddb mm0, mm0
psllq mm1, 4
pmovmskb edx, mm1
mov byte ptr [dest + 3], edx
paddb mm1, mm1
pmovmskb eax, mm0
pmovmskb edx, mm1
mov byte ptr [dest + 6], eax
mov byte ptr [dest + 2], edx
paddb mm0, mm0
paddb mm1, mm1
pmovmskb eax, mm0
pmovmskb edx, mm1
mov byte ptr [dest + 5], eax
mov byte ptr [dest + 1], edx
paddb mm0, mm0
paddb mm1, mm1
pmovmskb eax, mm0
pmovmskb edx, mm1
mov byte ptr [dest + 4], eax
mov byte ptr [dest], edx

つーか、全てにおいて最適なスケジューリングなんてねーだろよ

何も出来ないゴミが喚いても無駄