- 投稿日：2021-02-21T23:40:01+09:00
長押しで発火するボタンを作る
概要
一定時間長押しをして発火するようなボタンを作りたいということがよくあります。
ここではWPFでReactiveExtensionsを用いて次の3種類のボタンを作ります。
- 単純に長押しをしたら発火
- 長押しして発火するまでのProgressも表示して発火
- 長押しを止めたらProgressが戻り、再度押したら再開するResumableなもの
下準備
こんな感じの拡張メソッドを先に用意します。
ButtonExtensions.cspublic static class ButtonExtensions { public static IObservable<MouseButtonEventArgs> PreviewMouseDownAsObservable(this ButtonBase button) => Observable.FromEvent<MouseButtonEventHandler, MouseButtonEventArgs>( h => (s, e) => h(e), h => button.PreviewMouseDown += h, h => button.PreviewMouseDown -= h); public static IObservable<MouseButtonEventArgs> PreviewMouseUpAsObservable(this ButtonBase button) => Observable.FromEvent<MouseButtonEventHandler, MouseButtonEventArgs>( h => (s, e) => h(e), h => button.PreviewMouseUp += h, h => button.PreviewMouseUp -= h); }単純に長押ししたら発火
ボタン上でマウスダウンされたらタイマー開始、マウスアップがあったら中断ですね。
public static IObservable<long> LongPressAsObservable(this ButtonBase button, TimeSpan time) { var down = button.PreviewMouseDownAsObservable(); var up = button.PreviewMouseUpAsObservable(); return down .Select(_ => Observable.Timer(time).TakeUntil(up)) .Switch(); }使う時はこんな感じです。
LongPressという名前のボタンがあると思って下さい。
この例では2秒で発火しています。this.LongPress .LongPressAsObservable(TimeSpan.FromSeconds(2)) .ObserveOn(SynchronizationContext.Current) //.NET5にはObserveOnDispatcherがないので .Subscribe(_ => this.TestMessage.Text += $"LongPressed!:{DateTime.Now}\n"); //実行したいメソッドProgressも付ける
上ではシンプルなのを作りましたが、Progressが見えないといつまで押せばいいのか不安になりますね。
というわけでProgressがわかるようにしましょう。public static IObservable<double> ProgressAsObservable(this ButtonBase button, TimeSpan time) { var down = button.PreviewMouseDownAsObservable(); var up = button.PreviewMouseUpAsObservable(); //100になるまでGenerateしてもらいます。この100がトリガーです。 var progress = down .Select(_ => Observable .Generate(0d, i => i <= 100, i => ++i, i => i, i => time) .TakeUntil(up)); return progress.Switch(); } //ProgressというボタンとProgressBarというプログレスバーがあったとします this.Progress .ProgressAsObservable(TimeSpan.FromMilliseconds(1)) .ObserveOn(SynchronizationContext.Current) .Subscribe(x => { this.ProgressBar.Value = x; if (x.Equals(100d)) this.TestMessage.Text += $"ProgressCompleted!:{DateTime.Now}\n"; });ProgressをResumableにする
途中でボタンを押すのを止めたらProgressを戻して欲しい時もあります。
一瞬で0に戻ったらびっくりしますしね。
ただ100%完了してるのに戻られても困るからその辺りも何とかしましょう。public static IObservable<double> ResumableProgressAsObservable(this ButtonBase button, TimeSpan time) { double value = 0; double limit = 100d; var down = button.PreviewMouseDownAsObservable(); var up = button.PreviewMouseUpAsObservable(); var increment = down .Do(_ => { if (value.Equals(limit)) value = 0; }) .Select(_ => Observable.Generate(value, i => i <= 100, i => ++i, i => i, i => time).TakeUntil(up)); var decrement = up .Where(_ => !value.Equals(limit)) .Select(_ => Observable.Generate(value, i => i >= 0d, i => --i, i => i, i => time).TakeUntil(down)); return Observable.Merge(increment, decrement).Switch().Do(x => value = x); } // Resumableという名前のボタンがあるとします。 this.Resumable .ResumableProgressAsObservable(TimeSpan.FromMilliseconds(1)) .ObserveOn(SynchronizationContext.Current) .Subscribe(x => { this.ProgressBar.Value = x; if (x.Equals(100d)) this.TestMessage.Text += $"ResumableProgressCompleted!:{DateTime.Now}\n"; });もう少しスマートに書きたいですね。
補足
Tabキー等でフォーカスを失った際にもタイマーの進行を中止させたい場合は、LostFocusを監視しましょう。
ボタン上からマウスが外れた時は単純にMouseLeaveを監視すればいい、というわけにはならないのが辛いですね。
ボタンがマウスキャプチャをリリースしている必要があったりします。ソースコード
- 投稿日：2021-02-21T20:38:41+09:00
漢字（中国語）を左右に分割して表にしてみた＆百度百科（≒中国版wikipedia）へリンクしてみた／グレートファイアウォールの体験談
1. つくってみた
1.1. 動機 ～ 中国の漢字が読めない・・・
中国関連の仕事にどっぷり浸かっているのですが、漢字がわからん。。。ということで整理がてら作ってみた。
※へん（偏）とつくり（旁）の分割は完全に手作業です。辞書の索引見ながらつくりました。ピンイン入力も手作業なので間違ってる可能性あります。
数が多すぎるので、４画までしか作っていない。偏の選定はテキトウ。1.2. できたもの
See the Pen ExNXVGJ by kob58im (@kob58im) on CodePen.
1.3. テーブル変換用ツール(C#)
漢字テーブルを持たせるにあたり、JavaScriptの配列を手入力で作成するのはしんどいので、1.4章のテキストを1.3章のプログラムで変換をかけた。
コマンドプロンプトにおいて
chcp 65001でUTF-8にしておかないと、consoleにメッセージ吐いた場合に、日本語にない漢字が文字化けする。（ただし、IOException発生時にエラーメッセージのToString()に失敗する副作用がある模様。。）
テーブル変換用ツール(C#)
using System; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using System.Text.RegularExpressions; class ChConverter { [STAThread] static void Main(string[] args) { Regex rSection = new Regex(@"^===(.*)===$"); Regex rNumberOfStroke = new Regex(@"^---([0-9]+)---$"); Regex rKeyCharPair = new Regex(@"^([^\t]+)(?:\t([^\t]+)(?:\t([^\t]+))?)?$"); Regex rCharPair = new Regex(@"^([^\t]+)\t([^\t]+)\t([^\t]+)(?:\t([^\t]+))?$"); string[] lines = File.ReadAllLines("Ch.txt"); var sb = new StringBuilder(); int state = 0; int lineIndex = 1; int lastStrokeN = 0; var keyDict = new Dictionary<string,bool>(); sb.Append("const kt = ["); for ( ; lineIndex < lines.Length; lineIndex++ ) { string s = lines[lineIndex].Trim(); Match m; if ( s == "" ) { // do nothing } else if ( s == "#KeyOrderEnd" ) { lineIndex++; break; } else if ( s.StartsWith("#") ) { // do nothing } else if ( (m = rNumberOfStroke.Match(s)).Success ) { // do nothing } else if ( (m = rKeyCharPair.Match(s)).Success ) { string keyKanji = m.Groups[1].Value; string pinyin = GetNthValue(m, 2); string baikeId = GetNthValue(m, 3); sb.Append("['" + keyKanji + "'"); if ( !String.IsNullOrEmpty(pinyin) ) { sb.Append(",'" + pinyin + "'"); if ( !String.IsNullOrEmpty(baikeId) ) { sb.Append(",'" + baikeId + "'"); } } sb.Append("],"); if ( keyDict.ContainsKey(keyKanji) ) { Console.WriteLine("Warning: duplicated key. line " + (lineIndex+1).ToString()); } else { keyDict.Add(keyKanji, true); } } } sb.AppendLine("];"); sb.AppendLine("const ct = ["); for ( ; lineIndex < lines.Length; lineIndex++ ) { string s = lines[lineIndex].Trim(); Match m; if ( s == "" ) { // do nothing } else if ( s.StartsWith("#") ) { // do nothing } else if ( (m = rSection.Match(s)).Success ) { if ( state != 0 ) { sb.AppendLine("]],"); } state = 1; sb.Append("['"); sb.Append(m.Groups[1].Value); sb.Append("',["); } else if ( (m = rNumberOfStroke.Match(s)).Success ) { if ( state == 0 ) { Console.WriteLine("Format error. line " + (lineIndex+1).ToString()); return; } state = 2; lastStrokeN = Convert.ToInt32(m.Groups[1].Value); } else if ( (m = rCharPair.Match(s)).Success ) { if ( state == 0 || state == 1 ) { Console.WriteLine("Format error. line " + (lineIndex+1).ToString()); return; } string key = m.Groups[1].Value; string kanji = m.Groups[2].Value; string pinyin = m.Groups[3].Value; string baikeId = GetNthValue(m, 4); sb.Append("['" + key + "','" + kanji + "','" + pinyin + "'"); if ( !String.IsNullOrEmpty(baikeId) ){ sb.Append(",'" + baikeId + "'"); } sb.Append("],"); if ( !keyDict.ContainsKey(key) ) { Console.WriteLine("Warning: no key. line " + (lineIndex+1).ToString() + "\t" + lastStrokeN.ToString()+ "\t"+key); keyDict.Add(key,false); } } else { Console.WriteLine("Format error. line " + (lineIndex+1).ToString()); return; } } if ( state != 0 ) { sb.AppendLine("]]"); } sb.AppendLine("];"); try { File.WriteAllText("ch_for_js.txt", sb.ToString()); } catch ( IOException e ) { Console.WriteLine( "IOException" ); Console.WriteLine( e ); } } static string GetNthValue(Match m, int index) { if ( m.Groups.Count > index && m.Groups[index] != null && m.Groups[index].Value != null ) { return m.Groups[index].Value; } return null; } }1.4. 入力データ（抜粋）
入力データ（抜粋）
ch.txt#KeyOrderBegin ---0--- x ---1--- 乙 yǐ x扎 ---2--- 丁 dīng 丩 jiū 乃 nǎi 九 jiǔ 了 le/liào 二 èr 人 rén 八 bā 几 jī 刀 dāo 刁 diāo 力 lì 十 shí 卜 bǔ 又 yòu x汇 x朽 x化 x叩 （中略） 反 fǎn 壬 rén 5878659 （中略） #KeyOrderEnd ===言=== ---0--- x 言 yán ---2--- 丁 订 dìng 卜 讣 fù 几 讥 jī 十 计 jì 人 认 rèn ---3--- 己 记 jì 上 让 ràng 寸 讨 tǎo x讬 讬 tuō （以下略）1.5. 参考サイト
- CSSでテーブル表の一部を固定してスクロールする方法 | シンス株式会社
- CSS 文字の下線が消えない！？ - Qiita
- 実はヤバい？aタグと別タブで開く（target=”_blank”）の使い方｜株式会社WWG
- CodePen ： 中国語の四声変換ツールつくってみた（a1a2a3a4⇔āáǎà） - Qiita
2. グレートファイアウォールの話
※環境に依存する可能性があります。また、今後どうなるかも分かりません。
※事前に調べてみた感じだと、VPNのサーバーによっては、締め出しをくらっている場合があるという記載を見かけました。なお、かなり遅い＆たびたび切断される。。
2.1. VPNつないでもダメだったこと
- PCからだとgoogle検索(google.co.jp, google.com)にアクセスできず。。
- PCからだとgmailのメールが送信エラーとなる。。めちゃくちゃ時間経ってから送信できたりもする。（受信は（VPNつなげば）普通にできた。）
2.2. VPNつながないとダメだったこと
- スマホ/タブレットからgoogle検索
- スマホ/タブレットからYouTube
2.3. VPNつながなくてもできたこと
- Qiitaへのアクセス
- CodePen(codepen.io)へのアクセス
- 投稿日：2021-02-21T18:13:25+09:00
Xamarin.Android での Switch の使い方
はじめに
こんにちは、私が説明するのはタイトルにあるようにXamarin.AndroidでのSwitchの使い方です。私が以前Switchを使おうとした時に、Xamarin.Formsの方の解説はたくさんあるのにXamarin.Androidの解説が全くと言っていいほど無かったので書いておきます。
プログラミング環境はVisual Studio 2019です。作ったもの
今回は使い方を知りたかったのでSwitchを切り替えると文字が変わるだけのプログラムを書きました。
このようにSwitchが左の時はOff、右の時はOnと表示されるものです。まずはコードの前にSwitchの説明をします。
Switchについて
SwitchはOn Offなど、２つの値を切り替える時に使うものです。Android標準のアラームにも使われていますね。SwitchをUIに使いたい場合、Buttonなどと同じようにxmlまたはxamlファイルに書きます。私はxmlファイルでの書き方しか把握していないためこの記事ではxamlファイルの場合は解説できません。
xmlのコード
activity_main.xml<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <Switch android:layout_width="match_parent" android:layout_height="wrap_content" android:id="@+id/Switch" /> </LinearLayout>Switchを置きたい場合上図のように書けば配置できます、私は親LayoutをLinearLayoutにしていますが、適切なものを選べば他のLayoutでもできるはずです。
Switchでも横幅や高さの指定は他のものと変わらずにできidは必須です。続いてC#のコードです。
protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); Xamarin.Essentials.Platform.Init(this, savedInstanceState); // Set our view from the "main" layout resource SetContentView(Resource.Layout.activity_main); Switch sw = FindViewById<Switch>(Resource.Id.Switch); sw.Click += sw_Click; }
protected override void OnCreate(Bundle savedInstanceState)の中の下2行を書くだけでボタンをC#で使えるようにすることができます。このコードの場合、SwitchがClickされた時にsw_Click関数(後で定義する)が実行されるようになります。次にコード上での扱い方を説明します。
まずSwitchクラスswが上図のコードでは宣言されていますが、その中にCheckedというbool型の変数があり、Switchが左向き(初期の状態)ではfalse、右向き(初期の状態から1回押した状態)ではtrueが入っています。そのためsw内のCheckedさえ取り出すことができれば、あとは値を調べ、if文を使って値ごとの条件を書けば良いのです。取り出す方法は簡単でsw.Checkedだけです。あとはこれがtureかfalseかを調べればいいだけですので簡単ですね。では始めに載せた画像のアプリのコードを見てみましょう。アプリのコード
xml
activity_main.xml<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent"> <TextView android:textAppearance="?android:attr/textAppearanceLarge" android:layout_width="match_parent" android:layout_height="wrap_content" android:id="@+id/text" /> <Switch android:layout_width="match_parent" android:layout_height="wrap_content" android:id="@+id/Switch" /> </LinearLayout>C#
MainActivity.csusing Android.App; using Android.OS; using Android.Support.V7.App; using Android.Runtime; using Android.Widget; using System; namespace switch_exp { [Activity(Label = "@string/app_name", Theme = "@style/AppTheme", MainLauncher = true)] public class MainActivity : AppCompatActivity { public TextView text { get; private set; } protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); Xamarin.Essentials.Platform.Init(this, savedInstanceState); SetContentView(Resource.Layout.activity_main); text = FindViewById<TextView>(Resource.Id.text); Switch sw = FindViewById<Switch>(Resource.Id.Switch); sw.Click += sw_Click; } private void sw_Click(object sender, EventArgs e) { Switch sw = FindViewById<Switch>(Resource.Id.Switch); if(sw.Checked == true) { text.Text = "On"; } else { text.Text = "Off"; } } public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Android.Content.PM.Permission[] grantResults) { Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults); base.OnRequestPermissionsResult(requestCode, permissions, grantResults); } } }
protected override void OnCreate(Bundle savedInstanceState)はTextViewが増えただけで先程とほとんど変わりません。このコードで重要なのはprivate void sw_Click(object sender, EventArgs e)です。このアプリではSwitchの切り替えによって表示される文字が変化しますがそれをたったこれだけで書けてしまうのです。ifの条件式もsw.Checkedがtrueかfalseかを調べているだけで特に難しいわけでもなく、あとはifとelseそれぞれに処理を書いていけばSwitchは使えます。
ちなみにこのコードではOnCreateとsw_Click両方でSwitch型のクラスswを宣言していますが、これを関数の外(public class MainActivity : AppCompatActivity直下)に書くのはダメでしたので、今回は両方の関数で宣言しました。そのためこの2つは名前は同じですが全く別のクラスです。しかしそれぞれのクラスには全く同じSwitchが紐付けられているので問題なく動作します。
もしかしたら何か方法があるのかもしれませんができちゃったので今回はやりません。最後に
長々と書きましたがたったこれだけです、読むと難しく感じるかもしれませんがやってみると簡単だと感じるはずなのでぜひやってみてください。
それにしてもなんでXamarin.Androidの記事は全然無いんですかね、あったらこれを調べる必要無かったのに。。。
- 投稿日：2021-02-21T15:26:30+09:00
【備忘録】動的型付けと型推論の違い
はじめに
C#を勉強してると、
「varって動的型付けじゃないの？」
↓
「C#だとdynamicが動的型付けで、varは型推論なんだ」
↓
「てか、動的型付けと型推論って違うのか！」
となり、違いを理解していなかったので調べてみました。
ざっくりとした説明なので、詳しく知りたい人は自分で調べてちょ。動的型付け
実行時(Console.Write時)に型が決定されます。なので、下記のようになります。
// C# dynamic x = 100 // 動的型付けにより、変数xの型が数値型に決定する x = "Hello World !" // 型が動的に決定されるので、エラーがにならず変数xの型が文字列型になる Console.Write(x) // 「Hello World !」が表示される型推論
コンパイル時(上からコードが読み込まれる時)に型が決定されます。
// C# var x = 100 // Int型を指定しなくても、代入される値からコンパイラが変数xの型を自動で決定する(型推論) x = "Hello World !" // 型推論によりxがInt型に決定されているため、Int型以外を代入するとコンパイルエラーが発生 Console.Write(x) // コンパイルエラーのため実行できない補足
しかしながら、あくまで型推論である var と違って、dynamic で宣言した変数の型は「動的型」になります。
var sx = 1; // sx の型は int 型 dynamic dx = 1; // dx の型は dynamic 型
- 投稿日：2021-02-21T14:13:45+09:00
[Unity] C# JobSystem を利用してテキストファイルを非同期でパースする
一定時間ごとにある程度の大きさのテキストファイルを読み込んで、その内容を反映させるプロジェクトのため、Unity(C#)で使える高速なファイルアクセスAPIを調べて
AsyncReadManagerに行きつきました。偉大なる先駆者様 :
【Unity】ファイルを非同期で読み込んでアンマネージドメモリに展開できるAsyncReadManagerを試してみたこの先行研究ではメインスレッド上での動作確認とメモリ負荷の検証が主で、本文でさらっと
アンマネージドメモリにデータをキャッシュすると言いつつも、実装としてはJob等で並列化せずに愚直にメインスレッド上でパースを行っております。。(もう少し工夫すればJob化出来そうな気がしなくもなく。。要検証)
との表記に誘われて四苦八苦した結果、どうにか動くようになりましたので紹介させていただきます。
Unityプロジェクトなのに外部ファイル(しかもテキスト)をたくさん使うとか、非常にニッチな需要だとは思いますがそんな誰かの役にも立てばいいな……Unityアドカレに1個未投稿の枠があったので、今更ながら滑り込ませていただきました。
成果物
C# JobSystem で文字列の類をいい感じに扱うツールセットは最終的に以下のようになりました。
GitHub
NativeStringCollections動作環境
- Unity 2019.4.20f1
- Collections 0.9.0-preview.6
使い方
雰囲気はこんな感じ。
using NativeStringCollections public class TextData : ITextFileParser { NativeList<DataElement> Data; public void Init() { /* クラス初期化。 new() 後に一度だけ呼ばれる */ /* ここだけはメインスレッドで実行されるのでマネージ型を使ってもいい */ } public void Clear() { /* パース準備。 ParseLine(line) が始まる前に一度呼ばれる */ } public bool ParseLine(ReadOnlyStringEntity line) { /* line を解析する。 次の行も読みたいなら true を返す */ } public void PostProc() { /* 後処理。 ParseLine(line) が終わったら一度呼ばれる */ } public void UnLoad() { /* 一時的にデータを破棄したいときにここに処理を書く */ } } public class Hoge : MonoBehaviour { AsyncTextFileReader<TextData> reader; void Start() { reader = new AsyncTextFileReader<TextData>(Allocator.Persistent); } void Update() { // どこかでファイル読み込みの指示を出す (必要なら Encoding も指定する) reader.Encoding = Encoding.UTF8; reader.LoadFile(path); // 進捗を表示できる (Read, Length ともに BlockSize単位のint) var info = reader.GetState float progress = (float)info.Read / info.Length; // 終わってたら Complete() if(reader.JobState == ReadJobState.WaitForCallingComplete) { reader.Complete(); // 読み込みにかかった時間も出せる [ms] double delay = reader.GetState.Delay; Debug.Log($" file loading completed. time = {delay.ToString("F2")} [ms]."); // データを取り出して何かする var data = reader.Data; } } void OnDestroy() { // データのDispose() は外で行う。 reader だけ先に Dispose() してもよい var data = reader.Data; reader.Dispose(); data.Dispose(); } }文字列の具体的な変換はこんな感じ
using NativeStringCollections; public class TextData : ITextFileParser { public NativeList<DataElement> Data; private NativeStringList mark_list; private StringEntity check_mark; // パース中に string を使いたい場合は // Init() 内で NativeStringList や NativeList<char> に格納しておく public void Init() { Data = new NativeList<DataElement>(Allocator.Persistent); mark_list = new NativeStringList(Allocator.Persistent); mark_list.Add("STRONG"); mark_list.Add("Normal") // NativeStringList から StringEntity を取り出すのは値を全て格納してから // あるいは全ての文字列を格納しきれるようあらかじめ大きな Capacity を設定しておく // (StringEntity を取り出した後にバッファが再確保されると不正メモリ参照でクラッシュ) check_mark = mark_list[0]; } // 改行コードはあらかじめ解析されて行ごとに入力される public bool ParseLine(ReadOnlyStringEntity line) { // StringEntity.Split() の結果を受け取るリスト var str_list = new NativeList<ReadOnlyStringEntity>(Allocator.Temp); // カンマ区切りで "CharaName_STRONG,11,64,15.7,1.295e+3" みたいなデータだったなら line.split(',', str_list); // こんな風に var name = str_list[0]; bool success = true; success = success && str_list[1].TryParse(out long ID); success = success && str_list[2].TryParse(out int HP); success = success && str_list[3].TryParse(out float Attack); success = success && str_list[4].TryParse(out double Speed); // こんなことも var chara_tag = name.Slice(10, 16); // "STRONG" を抽出 if(chara_tag == check_mark) { /* このキャラ特有の何か */ } str_list.Dispose() // 正しいフォーマットとして解析できたか if(!success) return false; // 解釈できなかったのでパース中止 Data.Add(new DataElement(ID, HP, Attack, Speed)); return true; // 解釈できたので次の行に進む } }このような具合に。
実際には JobSystem の中で処理されますが、ユーザーが書く部分は通常のC#にだいぶ近い感じに設計できたと思います。また、上記
class TextDataは各プロジェクトにおいて適宜差し替えて使用することが前提ですが、常に JobSystem で実行されるとデバッグが面倒です。なのでメインスレッドでの実行を強制する下記のAPIもあります。var reader = new AsyncTextFileReader<NewProjectData>(Allocator.Persistent); reader.Encoding = Encoding.UTF8; reader.Path = path; // この場合 ParseLine(line) 内で Debug.Log() が使える。 // また、 var sb = new StringBuilder() や (obj).ToString() をしてもよい。 reader.LoadFileInMainThread(); if(reader.JobState == ReadJobState.WaitForCallingComplete) reader.Complete(); // データを取り出してデバッグする var data = reader.Data; reader.Dispose();ちなみに、先駆者様の例と同等のサイズの 50万キャラクターのファイルについて、当方の環境では
処理内容 経過時間 CharaData.ToString() をループで回してファイル出力 1100~1200ms CharaDataParser.ParseLine(line)で解析、格納 600~700ms となっており、 C# string と高速化の相性の悪さが如実に表れています。
(ファイル出力側は最適化について何も考えていないとはいえ……)とりあえず、これで
File.ReadAllLines()を使わずに済むようになるでしょう。中身のお話 (あるいは四苦八苦の記録)
string 使用禁止！ しかし Encoding や Parse() 、 Split() は欲しい……
C# string と JobSystem の相克
C# における文字列解析、というと、よくある例としては
Files.ReadAllLines()で string[] を受け取り、イテレータで行ごとに回してそこから望みのフォーマットにsplit()で切り出した後、数値に変換するならParse()メソッドを使用する、というパターンかと思います。
しかしこのデザインの根幹であるstringは参照型で、たとえGCHandleなどを使用し JobSystem に持ち込んでも string インスタンスの生成は当然できないのでString.Split()が使えません。
そこで本実装では Unity 2019.1 より char 型の NativeContainer を作成できるようになった ことを利用して、文字列はまるっとNativeList<char>に保持して、これにstringのように扱えるインターフェイスを被せることにしました。
まず文字列全体の管理として、string(のようなもの)が集合したcharについてのジャグ配列 に相当するコンテナにデータ本体を保持し、外側配列のインデックスアクセスで当該部分のスライスを取り出す、という形にします。List<string>のように使えることを目標とします。
大本の管理 struct は何となくジェネリックにします。
ジェネリックなデータ本体部
NativeJaggedArray<T>の実装(抜粋)NativeJaggedArray.cspublic struct NativeJaggedArray<T> : IDisposable, IEnumerable<NativeJaggedArraySlice<T>> where T : unmanaged, IEquatable<T> { internal struct ElemIndex { public int Start { get; private set; } public int Length { get; private set; } public int End { get { return this.Start + this.Length; } } public ElemIndex(int st, int len) { this.Start = st; this.Length = len; } } private NativeList<T> _buff; private NativeList<ElemIndex> _elemIndexList; #if ENABLE_UNITY_COLLECTIONS_CHECKS private NativeArray<long> genTrace; private PtrHandle<long> genSignature; #endif public unsafe NativeJaggedArray(Allocator alloc) { _buff = new NativeList<T>(alloc); _elemIndexList = new NativeList<ElemIndex>(alloc); _alloc = alloc; #if ENABLE_UNITY_COLLECTIONS_CHECKS genTrace = new NativeArray<long>(1, alloc); genSignature = new PtrHandle<long>((long)_buff.GetUnsafePtr(), alloc); // sigunature = address value of ptr for char_arr. #endif } public void Clear() { this._buff.Clear(); this._elemIndexList.Clear(); } public int Length { get { return this._elemIndexList.Length; } } public int Size { get { return this._buff.Length; } } public unsafe NativeJaggedArraySlice<T> this[int index] { get { var elem_index = this._elemIndexList[index]; T* elem_ptr = (T*)this._buff.GetUnsafePtr() + elem_index.Start; #if ENABLE_UNITY_COLLECTIONS_CHECKS return new NativeJaggedArraySlice<T>(elem_ptr, elem_index.Length, this.GetGenPtr(), this.GetGen()); #else return new NativeJaggedArraySlice<T>(elem_ptr, elem_index.Length); #endif } } public unsafe void Add(T* ptr, int Length) { int Start = this._buff.Length; this._buff.AddRange((void*)ptr, Length); this._elemIndexList.Add(new ElemIndex(Start, Length)); this.UpdateSignature(); } /// <summary> /// specialize for NativeJaggedArraySlice<T> /// </summary> /// <param name="slice"></param> public unsafe void Add(NativeJaggedArraySlice<T> slice) { this.Add((T*)slice.GetUnsafePtr(), slice.Length); } public void RemoveAt(int index) { this.CheckElemIndex(index); for (int i = index; i < this.Length - 1; i++) { this._elemIndexList[i] = this._elemIndexList[i + 1]; } this._elemIndexList.RemoveAtSwapBack(this.Length - 1); } #if ENABLE_UNITY_COLLECTIONS_CHECKS if (gap > 0) this.NextGen(); #endif } [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] unsafe private void UpdateSignature() { #if ENABLE_UNITY_COLLECTIONS_CHECKS long now_sig = GetGenSigneture(); if (now_sig != this.genSignature) { this.NextGen(); this.genSignature.Value = now_sig; } #endif } #if ENABLE_UNITY_COLLECTIONS_CHECKS private void NextGen() { long now_gen = this.genTrace[0]; this.genTrace[0] = now_gen + 1; } private unsafe long GetGenSigneture() { return (long)this._buff.GetUnsafePtr(); } private long GetGen() { return this.genTrace[0]; } unsafe private long* GetGenPtr() { return (long*)this.genTrace.GetUnsafePtr(); } #endif }
ジェネリックなスライス部分
NativeJaggedArraySlice<T>の実装(抜粋)NativeJaggedArraySlice.csunsafe public interface IJaggedArraySliceBase<T> where T: unmanaged, IEquatable<T> { int Length { get; } T this[int index] { get; } bool Equals(NativeJaggedArraySlice<T> slice); bool Equals(ReadOnlyNativeJaggedArraySlice<T> slice); bool Equals(T* ptr, int Length); void* GetUnsafePtr(); } public interface ISlice<T> { T Slice(int begin = -1, int end = -1); } [StructLayout(LayoutKind.Sequential)] public readonly unsafe struct NativeJaggedArraySlice<T> : IJaggedArraySliceBase<T>, IEnumerable<T>, IEquatable<IEnumerable<T>>, IEquatable<T>, ISlice<NativeJaggedArraySlice<T>> where T: unmanaged, IEquatable<T> { [NativeDisableUnsafePtrRestriction] internal readonly T* _ptr; internal readonly int _len; public int Length { get { return _len; } } #if ENABLE_UNITY_COLLECTIONS_CHECKS [NativeDisableUnsafePtrRestriction] internal readonly long* _gen_ptr; internal readonly long _gen_entity; #endif #if ENABLE_UNITY_COLLECTIONS_CHECKS public NativeJaggedArraySlice(T* ptr, int Length, long* gen_ptr, long gen_entity) { _ptr = ptr; _len = Length; _gen_ptr = gen_ptr; _gen_entity = gen_entity; } #else public NativeJaggedArraySlice(T* ptr, int Length) { _ptr = ptr; _len = Length; } #endif public T this[int index] { get { this.CheckReallocate(); return *(_ptr + index); } set { this.CheckReallocate(); this.CheckElemIndex(index); *(_ptr + index) = value; } } public NativeJaggedArraySlice<T> Slice(int begin = -1, int end = -1) { if (begin < 0) begin = 0; if (end < 0) end = _len; this.CheckSliceRange(begin, end); int new_len = end - begin; #if ENABLE_UNITY_COLLECTIONS_CHECKS this.CheckReallocate(); return new NativeJaggedArraySlice<T>(_ptr + begin, new_len, _gen_ptr, _gen_entity); #else return new NativeJaggedArraySlice<T>(_ptr + begin, new_len); #endif } [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] private void CheckReallocate() { #if ENABLE_UNITY_COLLECTIONS_CHECKS if(_gen_ptr == null && _gen_entity == -1) return; // ignore case for NativeJaggedArraySliceGeneratorExt if( *(_gen_ptr) != _gen_entity) { throw new InvalidOperationException("this slice is invalid reference."); } #endif } public void* GetUnsafePtr() { return _ptr; } }スライスは本当にポインタと長さしか持ちません (release build 時)。
Unity.CollectionsでNativeArray<T>からNativeSlice<T>は作れるのに対してNativeList<T>からは作れないのは、 List の伸縮に伴い内部バッファの再確保が行われた場合、メモリ上の位置が変わってそれまでに作ったポインタによる参照が無効になってしまうため、安全なスライスを作れないことが理由の一つとして考えられます。
今回の実装では、文字列の取り扱いとして最初にデータ全体の構築を行い、その後は要素の追加をせずにスライスの切り出しのみを行うことを基本方針としてちょっと危なめな設計にしました。
そうはいってもついやっちゃうこともあり得るので、要素の追加時に内部バッファの_buff.GetUnsafePtr()の値が変化したかどうかを確認し、それにより世代確認を行う関数CheckReallocate()を実装してあります。
UnityEditor 上であればやらかしを検知できます。これに文字列に特化したインターフェイスを被せてジャグ配列の
NativeStringListとスライスのStringEntityとします。(今更だけど怒られそうな名前を付けてしまった……)
NativeStringListの実装(抜粋)NativeStringList.cspublic struct NativeStringList : IDisposable, IEnumerable<StringEntity> { private NativeJaggedArray<char> _jarr; public unsafe NativeStringList(Allocator alloc) { _jarr = new NativeJaggedArray<char>(alloc); } public void Dispose() { _jarr.Dispose(); } public unsafe StringEntity this[int index] { get; } public StringEntity Last { get; } // string のようなものへの特殊化 public void Add(IEnumerable<char> str) { _jarr.Add(str); } public unsafe void Add(char* ptr, int Length) { _jarr.Add(ptr, Length); } public unsafe void Add(StringEntity entity) { this.Add((char*)entity.GetUnsafePtr(), entity.Length); } public unsafe void Add(ReadOnlyStringEntity entity) { this.Add((char*)entity.GetUnsafePtr(), entity.Length); } public unsafe void Add(NativeList<char> str) { this.Add((char*)str.GetUnsafePtr(), str.Length); } public unsafe void Add(NativeArray<char> str) { this.Add((char*)str.GetUnsafePtr(), str.Length); } }
StringEntityの実装(抜粋)StringEntity.cspublic unsafe readonly struct StringEntity : IParseExt, IJaggedArraySliceBase<char>, ISlice<StringEntity>, IEquatable<string>, IEquatable<char[]>, IEquatable<IEnumerable<char>>, IEquatable<char>, IEnumerable<char> { /* 中略 */ /* string のようなものへの特殊化 */ public bool Equals(char* ptr, int Length) { this.CheckReallocate(); if (_len != Length) return false; // pointing same target if (_ptr == ptr) return true; for (int i = 0; i < _len; i++) { if (_ptr[i] != ptr[i]) return false; } return true; } public bool Equals(StringEntity entity) { this.CheckReallocate(); return entity.Equals(_ptr, _len); } public bool Equals(ReadOnlyStringEntity entity) { this.CheckReallocate(); return entity.Equals(_ptr, _len); } public bool Equals(NativeJaggedArraySlice<char> slice) { this.CheckReallocate(); return slice.Equals(_ptr, _len); } public bool Equals(ReadOnlyNativeJaggedArraySlice<char> slice) { this.CheckReallocate(); return slice.Equals(_ptr, _len); } public bool Equals(string str) { if (this.Length != str.Length) return false; return this.SequenceEqual<char>(str); } public bool Equals(char[] c_arr) { if (this.Length != c_arr.Length) return false; return this.SequenceEqual<char>(c_arr); } public bool Equals(char c) { return (this.Length == 1 && this[0] == c); } public bool Equals(IEnumerable<char> in_itr) { this.CheckReallocate(); return this.SequenceEqual<char>(in_itr); } public static bool operator ==(StringEntity lhs, StringEntity rhs) { return lhs.Equals(rhs); } public static bool operator !=(StringEntity lhs, StringEntity rhs) { return !lhs.Equals(rhs); } public static bool operator ==(StringEntity lhs, ReadOnlyStringEntity rhs) { return lhs.Equals(rhs); } public static bool operator !=(StringEntity lhs, ReadOnlyStringEntity rhs) { return !lhs.Equals(rhs); } public static bool operator ==(StringEntity lhs, IEnumerable<char> rhs) { return lhs.Equals(rhs); } public static bool operator !=(StringEntity lhs, IEnumerable<char> rhs) { return !lhs.Equals(rhs); } public override bool Equals(object obj) { return obj is StringEntity && ((IJaggedArraySliceBase<char>)obj).Equals(_ptr, _len); } public ReadOnlyStringEntity GetReadOnly() { return new ReadOnlyStringEntity(this); } public void* GetUnsafePtr() { return _ptr; } }これで
stringのようなもの同士で比較したり、スライスを切り出したりやりたい放題できるようになりました。
なお、NativeJaggedArray<T>のほうを使えば任意のstructについてユーザー管理の共通バッファへの参照を JobSystem と GameObject の両方にばらまくことができてしまいます。ポインタ無法地帯へはあと一歩のぎりぎりのラインにいるので、ご利用は計画的に。Encoder の自力実装は勘弁してほしい
- なので
GCHandleで JobSystem の中に持っていく
Encoder,Decoderをバグなく実装する自信はないですし、さらに日本語の文字コードは Unicode系列 (UTF-8, UTF-16, UTF-32)のほかに Shift-JISやらEUC-JP、 ISO-2022-JPなどどんなデータを読む羽目になるか分かったものではありません。(特に古いシステムの吐いたデータほど。)
幸い C# 標準にDecoder.GetChars(byte*, int, char* ,int)関数が用意されており、GCHandleで持ち込みさえすれば JobSystem で使えます。- 日本ローカルの Encoding に注意！
上で上げたエンコーディングのうち、Shift-JIS、EUC-JP、ISO-2022-JP の３つは UnityEditor上では普通に使えますがビルドすると必要なDLLが欠けるためプレイヤーがこけます。
上の記事で対応は可能ですが、レガシーの文字エンコードの対応が適当……
(いやゲームエンジンとしては不要なモノなのでまっとうな設計ではあるのですが)TryParse(), Split(), Strip() は自力実装
文字列解析用データ構造として
StringEntityを自作してしまったので、これらのユーティリティも当然自作します。
実装の単純化のため、C#ではParse()メソッドで一緒くたになっていた十進表記と１６進数表記の解析をTryParse()とTryParseHex()に分離します。パーサーを作るにあたって、どちらの表記かわからない、なんてことはないでしょうし、そもそもHexフォーマットを使う状況というのはfloatやdoubleの値を確実に読み書きしたい状況ぐらいでしょう。
Split(),Strip()については、さっそくStringEntity.Slice()の出番です。普通に線形探索して結果を切り出します。Base64 の変換もできると便利
前節で
TryParseHex()を用意したものの、データの利用効率が劣悪(4bit -> 8bit と必要分で単純に倍、プリフィックスに0xをつければ 2B 追加。ASCIIコード換算でfloatが 4B -> 10B = 250% になる)なので配列や構造体の生バイト列などの大きなものには正直向いていません。
というわけで由緒正しき Base64 のコンバータを用意しましょう。
C# Reference Source の実装を参考に、テーブル変換なので中身は単純です。
Base64コンバータの実装(抜粋)
StringParser.cs/// <summary> /// The Encoder for MIME Base64 (RFC 2045). /// </summary> public struct NativeBase64Encoder : IDisposable { private Base64EncodeMap _map; private PtrHandle<Base64Info> _info; /// <summary> /// convert bytes into chars in Base64 format. /// </summary> /// <param name="buff">output</param> /// <param name="byte_ptr">source ptr</param> /// <param name="byte_len">source length</param> /// <param name="splitData">additional bytes will be input or not. (false: call Terminate() internally.</param> public unsafe void GetChars(NativeList<char> buff, byte* byte_ptr, int byte_len, bool splitData = false) { if (byte_len < 0) throw new ArgumentOutOfRangeException("invalid bytes length."); uint store = _info.Target->store; int bytePos = _info.Target->bytePos; int charcount = 0; for(uint i=0; i<byte_len; i++) { if (_info.Target->insertLF) { if (charcount == Base64Const.LineBreakPos) { buff.Add('\r'); buff.Add('\n'); charcount = 0; } } store = (store << 8) | byte_ptr[i]; bytePos++; // encoding 3 bytes -> 4 chars if(bytePos == 3) { buff.Add(_map[(store & 0xfc0000) >> 18]); buff.Add(_map[(store & 0x03f000) >> 12]); buff.Add(_map[(store & 0x000fc0) >> 6]); buff.Add(_map[(store & 0x00003f)]); charcount += 4; store = 0; bytePos = 0; } } _info.Target->store = store; _info.Target->bytePos = bytePos; if (!splitData) this.Terminate(buff); } /// <summary> /// apply termination treatment. /// </summary> /// <param name="buff">output</param> public unsafe void Terminate(NativeList<char> buff) { uint tmp = _info.Target->store; switch (_info.Target->bytePos) { case 0: // do nothing break; case 1: // two character padding needed buff.Add(_map[(tmp & 0xfc) >> 2]); buff.Add(_map[(tmp & 0x03) << 4]); buff.Add(_map[64]); // pad buff.Add(_map[64]); // pad break; case 2: // one character padding needed buff.Add(_map[(tmp & 0xfc00) >> 10]); buff.Add(_map[(tmp & 0x03f0) >> 4]); buff.Add(_map[(tmp & 0x000f) << 2]); buff.Add(_map[64]); // pad break; } _info.Target->store = 0; _info.Target->bytePos = 0; } public void Dispose() { _map.Dispose(); _info.Dispose(); } } /// <summary> /// The Decoder for MIME Base64 (RFC 2045). /// </summary> public struct NativeBase64Decoder : IDisposable { private Base64DecodeMap _map; private PtrHandle<Base64Info> _info; /// <summary> /// convert Base64 format chars into bytes. /// </summary> /// <param name="buff">output</param> /// <param name="char_ptr">source ptr</param> /// <param name="char_len">source length</param> /// <returns>convert successfull or not</returns> public unsafe bool GetBytes(NativeList<byte> buff, char* char_ptr, int char_len) { if (char_len < 0) { #if UNITY_EDITOR throw new ArgumentOutOfRangeException("invalid chars length."); #else return false; #endif } uint store = _info.Target->store; int bytePos = _info.Target->bytePos; for(int i=0; i<char_len; i++) { char c = char_ptr[i]; if (this.IsWhiteSpace(c)) continue; if(c == '=') { switch (bytePos) { case 0: case 1: #if UNITY_EDITOR throw new ArgumentException("invalid padding detected."); #else return false; #endif case 2: // pick 1 byte from "**==" code buff.Add((byte)((store & 0x0ff0) >> 4)); bytePos = 0; break; case 3: // pick 2 byte from "***=" code buff.Add((byte)((store & 0x03fc00) >> 10)); buff.Add((byte)((store & 0x0003fc) >> 2)); bytePos = 0; break; } return true; } else { uint b = _map[c]; if (b != 255) { store = (store << 6) | (b & 0x3f); bytePos++; } } if(bytePos == 4) { buff.Add((byte)((store & 0xff0000) >> 16)); buff.Add((byte)((store & 0x00ff00) >> 8)); buff.Add((byte)((store & 0x0000ff))); store = 0; bytePos = 0; } } _info.Target->store = store; _info.Target->bytePos = bytePos; return true; } private bool IsWhiteSpace(char c) { return (c == ' ' || c == '\t' || c == '\n' || c == '\r'); } } internal struct Base64EncodeMap : IDisposable { private NativeArray<byte> _map; public Base64EncodeMap(Allocator alloc) { _map = new NativeArray<byte>(65, alloc); int i = 0; for(byte j=65; j<=90; j++) // 'A' ~ 'Z' { _map[i] = j; i++; } for(byte j=97; j<=122; j++) // 'a' ~ 'z' { _map[i] = j; i++; } for(byte j=48; j<=57; j++) // '0' ~ '9' { _map[i] = j; i++; } _map[i] = 43; i++; // '+' _map[i] = 47; i++; // '/' _map[i] = 61; // '=' } public char this[uint index] { get { if (index > 65) throw new ArgumentOutOfRangeException("input byte must be in range [0x00, 0x40]."); return (char)_map[(int)index]; } } } internal struct Base64DecodeMap : IDisposable { private NativeArray<byte> _map; public Base64DecodeMap(Allocator alloc) { _map = new NativeArray<byte>(80, alloc); int i = 0; _map[i] = 62; i++; // 0x2b, '+' for(int j=0; j<3; j++) { _map[i] = 255; i++; // invalid code } _map[i] = 63; i++; // 0x2f, '/' for(byte j=52; j<=61; j++) { _map[i] = j; i++; // '0' ~ '9' } for(byte j=0; j<7; j++) { _map[i] = 255; i++; // invalid code } for(byte j=0; j<=25; j++) { _map[i] = j; i++; // 'A' ~ 'Z' } for(byte j=0; j<6; j++) { _map[i] = 255; i++; // invalid code } for (byte j = 26; j <= 51; j++) { _map[i] = j; i++; // 'a' ~ 'z' } } public byte this[uint index] { get { if (index < 0x2b) return 255; if (index > 0x7a) return 255; return _map[(int)(index - 0x2b)]; } } }元のリファレンスでは全ビットパターン分(16*16=256)テーブルが作ってありましたが、有効な値は64種類、いくつか途中にある無効な値を考慮しても端から端まで長さ80あれば足りるので、今回の実装ではせっかくなので小さくしてみました。
どうせならユーザー定義データも class にしてしまえばいい
Encodingを持ち込むと決めた段階で、byte列 -> char列の変換処理に Burst を使えないことが確定しました。
ジョブ丸ごとの struct 化とかもう気にしなくていいので、ユーザー定義のデータコンテナも class ということにして、これもGCHandleでJobSystemへ持って行きます。
ただしこの設計により、誤って struct のデータコンテナを渡したところ当然ながら GCHandle の取得でコケたので、最終的に class のみを受け取る形にしました。ポインタがすべてを解決する
実はこの段階のパース速度は Chara 50万体のデータに ~ 1300 ms 程度とだいぶ遅かったのですが、プロファイラを確認したところ主要な処理負荷がインデクサ
this[index]やLengthフィールドから値を取り出すところだったので、ライブラリ内の処理実装部分では最初にvoid*とLengthを取り出してポインタで直接処理するようにしました。その高速化の経過は下記の通り。
処置した関数 速度 StringSplitter.Split() ~1000 ms 上記に加え、 TextDecoder.ParseLineImpl() + NativeStringList を ref 渡し 700 ~ 800 ms 上記に加え、 StringParserExt.TryParse() 600 ~ 700 ms 見やすいプロファイラは素晴らしい。
また、欲しい関数の追加や処理のバッファとして内部的に使う、などにより
NativeContinerに似たものを多数作成しましたが、状態管理用の変数ごとにポインタを作るのは手間がかかる上に事故の危険もコピーコストも増大する挙句、データがメモリ上に分散して性能に悪影響を及ぼします。
よって、ジェネリックなポインタ管理ヘルパーPtrHandle<T>を作りましょう。
ポインタ管理ヘルパー
PtrHandle<T>の実装PtrHandle.csnamespace NativeStringCollections.Utility { public unsafe struct PtrHandle<T> : IDisposable where T : unmanaged { [NativeDisableUnsafePtrRestriction] private T* _ptr; private Allocator _alloc; private Boolean _isCreated; public PtrHandle(Allocator alloc) { if (alloc <= Allocator.None) throw new ArgumentException("Allocator must be Temp, TempJob or Persistent", nameof(alloc)); _alloc = alloc; _ptr = (T*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<T>(), UnsafeUtility.AlignOf<T>(), _alloc); _isCreated = true; } public PtrHandle(T value, Allocator alloc) { if (alloc <= Allocator.None) throw new ArgumentException("Allocator must be Temp, TempJob or Persistent", nameof(alloc)); _alloc = alloc; _ptr = (T*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<T>(), UnsafeUtility.AlignOf<T>(), _alloc); _isCreated = true; *_ptr = value; } public Boolean IsCreated { get { return (_isCreated); } } public void Create() { _ptr = (T*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<T>(), UnsafeUtility.AlignOf<T>(), _alloc); _isCreated = true; } public void Dispose() { if (IsCreated) { this.CheckAllocator(); UnsafeUtility.Free((void*)_ptr, _alloc); _ptr = null; _isCreated = false; } else { throw new InvalidOperationException("Dispose() was called twise, or not initialized target."); } } public T* Target { get { if (!_isCreated) throw new InvalidOperationException("target is not allocated. call Create()."); return _ptr; } } public T Value { set { *_ptr = value; } get { return *_ptr; } } public static implicit operator T(PtrHandle<T> value) { return *value._ptr; } private void CheckAllocator() { if (!UnsafeUtility.IsValidAllocator(_alloc)) throw new InvalidOperationException("The buffer can not be Disposed because it was not allocated with a valid allocator."); } } }この
PtrHandle<T>を使用して、NativeContinerに似た struct の状態変数は以下のように一括管理ができるようになります。struct MyInfo { public int Size; public bool Flag; public MyStateEnum State; } struct MyProcessor<T> : IDisposable where T: unmanaged { private NativeList<T> _buffer; private PtrHandle<MyInfo> _info; public MyProcessor(Allocator alloc) { _buffer = new NativeList<T>(alloc); _info = new PtrHandle<T>(alloc); } public unsafe void Execute() { if(_info.Target->State == MyStateEnum.Default) { /* 何か処理 */ } } }また、これも GameObject 側と JobSystem 側での変数の共有に使えるので、(外部に渡す場合には内容を別の出力専用
readonly structにコピーしてから返すなどの安全対策をしておけば) Job の管理にも有用です。
デモでファイル読み込みの進捗状況を取得して表示させていますが、内部的にはPtrHandle<T>を利用しています。すでに
NativeArrayの運用に習熟していらっしゃる皆様もお気づきのことでしょうが、実は上記の「あるunmanaged structをポインタ経由で管理したい」という状況は、サイズ1のNativeArrayでも代用できなくはありません。しかし、UnityEditor上でのみではありますが、デバッグ用の安全装置の存在のためNativeContainerはマネージド型変数を持っており、NativeArray<NativeArray<T>>のようなものは作れません。またNativeContainerはインデクサアクセスでは保持しているstructのコピーを出し入れする形となり、状態変数の取り扱いは書きやすいとは言えません。
以上、安全装置のないPtrHandle<T>を使ってしまった言い訳でしたが、大抵は別のNativeContainerとセットで運用しているはずなので、AllocateもDispose()もセットで書いてやれば大丈夫です。
そんなこと言いつつ昨日メモリリーク1ヵ所見つけましたごめんなさいライブラリに閉じ込めるなどしてポインタが暴れださないようにできれば、ポインタはすべてを解決する。
in readonly struct で速くな……らない！
実はしれっとスライスの実装を
readonly structで定義していたので、さらなるコピー削減のためStringEntityを引数に渡している部分にinをつけてみます。その結果……100 ms 程遅くなりました。
そもそも最初に頑張ってスライスを軽量化した結果、パディングの具合にもよりますがリリースビルドでは 8 byte ~ 16 byte のフットプリントしかありません。小さい struct では in readonly struct を渡して低速化する報告もあり、常々言われることではありますがやはり最適化に計測と確認は必須です。文字列デコードのブロック処理
C# における
charは最小データサイズが 2 byte になる UTF-16 が採用されています。ここで、例えば UTF-8 でエンコードされた、ほぼASCIIコードのテキストファイル(=ファイル上ではほぼ全て 1 byte)を一気にデコードすると、メモリ上にファイルサイズの倍の大きさの char配列が出現します。元のファイルサイズがMBクラスの大きさならあっという間にCPUのキャッシュからはみ出して処理速度が悲しいことになります。
というわけで、キャッシュ内でパース処理をするためにブロック単位で char に変換し、改行コードを解析して line を示すスライスに切り出し、ブロック内の切り出しが終わったら出来上がった line をITextFilePaser.ParseLine(line)に流し込みます。
この line の切り出しの表現に、先頭部分のカタマリの挿入、削除に対応するラッパーを被せたNativeHeadRemovableList<T>を使用します。
NativeHeadRemovableList<T>の実装(抜粋)NativeHeadRemovableList.csinternal struct NativeHeadRemovableList<T> : IDisposable where T : unmanaged { private NativeList<T> _list; private PtrHandle<int> _start; public unsafe NativeHeadRemovableList(Allocator alloc) {} public unsafe T this[int index] { get { return _list[_start + index]; } set { _list[_start + index] = value; } } public unsafe int Length { get { return _list.Length - _start; } } /* 中略 */ public unsafe void RemoveHead(int count = 1) { if (count < 1 || Length < count) throw new ArgumentOutOfRangeException("invalid length of remove target."); _start.Value = _start + count; } public unsafe void InsertHead(T* ptr, int length) { if (length <= 0) throw new ArgumentOutOfRangeException("invalid size"); // when enough space exists in head if (length <= _start) { _start.Value = _start - length; UnsafeUtility.MemCpy(this.GetUnsafePtr(), ptr, UnsafeUtility.SizeOf<T>() * length); return; } // slide internal data int new_length = length + this.Length; int len_move = this.Length; _list.ResizeUninitialized(new_length); T* dest = (T*)_list.GetUnsafePtr() + length; T* source = (T*)_list.GetUnsafePtr() + _start; UnsafeUtility.MemMove(dest, source, UnsafeUtility.SizeOf<T>() * len_move); // insert data _start.Value = 0; UnsafeUtility.MemCpy((void*)_list.GetUnsafePtr(), (void*)ptr, UnsafeUtility.SizeOf<T>() * length); } }改行を見つけたら当該部分のコピー後に
NativeHeadRemovableList<T>.RemoveHead(int)で１行分ごそっと消しますが、内部的には_startに長さ分足しているだけです。また、ブロック処理の都合上末尾に未処理のデータ片が残り、これを次回の処理開始時に配列の先頭に移動させねばなりません。そのために
NativeHeadRemovableList<T>.InsertHead(T*, int)を実装した……のですが、処理手順を考えると char配列の受け取り前に残ったデータをUnsafeUtility.MemMove()で先頭に移動して、Decoder.GetChars(byte*, int, char* ,int)に渡すポインタをその続きにすれば一番効率的だったことにこれを書いてる今気づきました。
現状で性能にほぼ影響がないので放置していますが、これから似たようなことをやる人はご注意ください。
いまどきこんな低レベルなところを弄る人がどのくらいいるかわかりませんが……具体的なブロックサイズについては、当方の検証では 2kB ~ 4kB 程度が一番よさげでしたので、2kB を規定値として採用しました。
注文も非同期な感じで受け付けてほしい
さて、これでそこそこの速度でテキストファイルをパースできるようになったわけですが、せっかく非同期なので追加の要求です。複数の GameObject から好き勝手に Load, UnLoad の要求が出される状況に対応しましょう。
複数ファイルへの複数のユーザーからの問い合わせに対応するバージョンとして
AsyncTextFileLoader<T>を作ります。
AsyncTextFileLoader<T>の実装(抜粋)AsyncTextFileLoader.cspublic class AsyncTextFileLoader<T> : IDisposable where T : class, ITextFileParser, new() { private List<string> _pathList; private Encoding _encoding; private Allocator _alloc; private Dictionary<int, ParseJob<T>> _parserPool; private int _gen; private int _blockSize; private int _maxJobCount; private NativeList<RunningJobInfo> _runningJob; private NativeList<PtrHandle<ReadStateImpl>> _state; private List<T> _data; private struct RunningJobInfo { public int FileIndex { get; } public int ParserID { get; } public RunningJobInfo(int file_index, int parser_index) { FileIndex = file_index; ParserID = parser_index; } } private enum FileAction { Store = 1, UnLoad = -1, } private struct Request { public int fileIndex { get; } public FileAction action { get; } public Request(int index, FileAction action) { fileIndex = index; this.action = action; } } private NativeQueue<int> _parserAvail; private NativeList<Request> _requestList; private NativeList<int> _updateLoadTgtTmp; private NativeList<int> _updateUnLoadTgtTmp; private UnLoadJob<T> _unLoadJob; /* 中略 */ public int MaxJobCount { get { return _maxJobCount; } set { if(value > 0) _maxJobCount = value; } } public int LoadWaitingQueue { get { return _loadWaitingQueueNum; } } public bool FlushLoadJobs { get; set; } // 管理対象のファイルが追加されたら担当のデータクラス T を生成 public unsafe void AddFile(string str) { _pathList.Add(str); _data.Add(new T()); _data[_data.Count - 1].Init(); var s_tmp = new PtrHandle<ReadStateImpl>(_alloc); s_tmp.Target->Clear(); _state.Add(s_tmp); } // データとJobの状態について index でアクセス public unsafe T this[int fileIndex] { get { if (!_state[fileIndex].Target->IsStandby) throw new InvalidOperationException($"the job running now for fileIndex = {fileIndex}."); return _data[fileIndex]; } } public unsafe ReadState GetState(int index) { return _state[index].Target->GetState(); } // Load, UnLoad ともに外部からの注文はいったんリストにためて Update() で処理 public void LoadFile(int index) { _loadWaitingQueueNum++; _requestList.Add(new Request(index, FileAction.Store)); } public void UnLoadFile(int index) { _requestList.Add(new Request(index, FileAction.UnLoad)); } public void Update() { this.UpdateImpl(this.FlushLoadJobs); this.FlushLoadJobs = false; } // リストにためた注文を一気に処理する private unsafe void UpdateImpl(bool flush_all_jobs = false) { // check job completed or not for (int i= _runningJob.Length-1; i>=0; i--) { var job_info = _runningJob[i]; var read_state = _state[job_info.FileIndex]; if (read_state.Target->JobState == ReadJobState.WaitForCallingComplete) { _parserPool[job_info.ParserID].Complete(); read_state.Target->JobState = ReadJobState.Completed; this.ReleaseParser(job_info.ParserID); _runningJob.RemoveAt(i); } } if(_unLoadJob.JobState == ReadJobState.WaitForCallingComplete) { _unLoadJob.Complete(); _unLoadJob.Clear(); } // no requests. or all available parser were running. retry in next Update(). if (_requestList.Length == 0 || (_maxJobCount - _runningJob.Length <= 0 && !flush_all_jobs)) { return; } //--- extract action _updateLoadTgtTmp.Clear(); _updateUnLoadTgtTmp.Clear(); for (int i=0; i<_requestList.Length; i++) { var act = _requestList[i]; if (act.action == FileAction.Store) { var tgt_state = _state[act.fileIndex]; if (tgt_state.Target->RefCount == 0) { _updateLoadTgtTmp.Add(act.fileIndex); } tgt_state.Target->RefCount++; } else { _updateUnLoadTgtTmp.Add(act.fileIndex); } } _requestList.Clear(); //--- preprocess unload action for (int i=0; i< _updateUnLoadTgtTmp.Length; i++) { int id = _updateUnLoadTgtTmp[i]; var tgt_state = _state[id]; tgt_state.Target->RefCount--; if (tgt_state.Target->RefCount == 0) { int found_index = _updateLoadTgtTmp.IndexOf(id); if (found_index >= 0) { // remove from loading order (file loading is not performed) _updateLoadTgtTmp.RemoveAtSwapBack(found_index); } else { // remove from loaded data if (_unLoadJob.JobState == ReadJobState.Completed && tgt_state.Target->IsStandby) { //--- unload in job (workaround for LargeAllocation.Free() cost in T.UnLoad().) _unLoadJob.AddUnLoadTarget(id, _data[id], _state[id]); } else { // now loading. unload request will try in next update. tgt_state.Target->RefCount++; // reset ref count this.UnLoadFile(id); } } } if (tgt_state.Target->RefCount < 0) { throw new InvalidOperationException($"invalid UnLoading for index = {id}."); } } _updateUnLoadTgtTmp.Clear(); // schedule jobs //--- unload job _unLoadJob.UnLoadAsync(); //--- supply parsers for load job int n_add_parser = Math.Max(_updateLoadTgtTmp.Length - _parserAvail.Count, 0); if (!flush_all_jobs) { n_add_parser = Math.Min(this.MaxJobCount - _parserPool.Count, n_add_parser); } for (int i = 0; i < n_add_parser; i++) this.GenerateParser(); //--- run jobs int n_job = Math.Min(_parserAvail.Count, _updateLoadTgtTmp.Length); for(int i=0; i<n_job; i++) { int file_index = _updateLoadTgtTmp[i]; int p_id = _parserAvail.Dequeue(); var p_tmp = _parserPool[p_id]; var p_state = _state[file_index]; p_tmp.BlockSize = _blockSize; p_tmp.ReadFileAsync(_pathList[file_index], _encoding, _data[file_index], p_state); _runningJob.Add(new RunningJobInfo(file_index, p_id)); } //--- write back excessive queue _loadWaitingQueueNum = 0; for (int i=n_job; i<_updateLoadTgtTmp.Length; i++) { int id = _updateLoadTgtTmp[i]; _state[id].Target->RefCount--; // reset ref count this.LoadFile(id); _loadWaitingQueueNum++; } _updateLoadTgtTmp.Clear(); } }大まかな流れとしては、
- (
Update()が呼ばれるまで) 任意の Load, UnLoad を受け付けてすべてリストにためる- たまった注文を Load と UnLoad に分ける
- まず Load だけを取り出し、各ファイルの参照カウントをインクリメントし、
ここで参照カウントが0→1になったなら LoadJob の予約表に書きこむ- 次に UnLoad だけを取り出し、各ファイルの参照カウントをデクリメントし、
ここで参照カウントが1→0になったなら、
- LoadJob の予約表に該当ファイルの予約があれば、それを消す (その結果何もしない)
- 予約がなければ UnLoadJob の対象リストに入れる
- UnLoadJob を
schedule()する。- LoadJob を
schedule()する。Load だけでなく UnLoad も Job にしてしまっていますが、これについては次節で説明します。
ここにさらに同時に動作する LoadJob の最大数
MaxJobCountに合わせて、同時に保持するパーサーの数とジョブの割り当てを管理しています。
パーサーは一度動かすとファイル丸ごとをバッファすること、またそもそもファイルのロードは多数を同時に走らせることは稀という前提で、メモリ消費の削減の観点からこのような設計にしました。しかし、後述の課題によりMaxJobCountはせいぜい 1 ~ 2 ぐらいまでしかまともに動かないことが判明しました。実際の運用では、 LoadJob 待機中の注文数を取得するプロパティ
AsyncTextFileLoader<T>.LoadWaitingQueueを参照して注文する GameObject 側がタイミングを調節する形になるでしょう。大きなデータのUnLoad
大きなファイルの読み込みもそうですが、メモリ領域の破棄にもそれなりにコストがかかります。
大容量のデータをいくつも一気に UnLoad したりするとLargeAllocation.Free()に ms 単位で持っていかれかねません。せっかくパース処理そのものはワーカースレッドに追い出したのに、これでメインスレッドが遅くなったら片手落ちです。
幸いNativeContainerのアロケータはワーカースレッドでも動くので、多数のファイルを管理するAsyncTextFileLoader<T>ではUnLoad()もワーカースレッドにやらせてメインスレッドを身軽にします。
ここで、JobHandle.Schedule()の呼び出しコストを削減するため、UnLoad()対象のデータ (のGCHandle)のリストを1つの Job に渡して一気に UnLoad させます。
UnLoad 用の Job は以下のようになります。
UnLoadJob<T>の実装(抜粋)ParseJob.csinternal struct UnLoadJobTarget<Tdata> where Tdata : class, ITextFileParser { internal GCHandle<Tdata> data; internal PtrHandle<ReadStateImpl> state_ptr; // UnLoad 対象の State internal int file_index; public UnLoadJobTarget(int file_index, Tdata data, PtrHandle<ReadStateImpl> state_ptr) { this.data = new GCHandle<Tdata>(); this.data.Create(data); this.state_ptr = state_ptr; this.file_index = file_index; } public unsafe void UnLoad() { this.state_ptr.Target->JobState = ReadJobState.UnLoaded; this.data.Target.UnLoad(); } } internal struct UnLoadJobInfo { internal ReadJobState job_state; internal JobHandle job_handle; internal Boolean alloc_handle; } internal struct UnLoadJob<Tdata> : IJob, IDisposable where Tdata : class, ITextFileParser { internal NativeList<UnLoadJobTarget<Tdata>> _target; internal PtrHandle<UnLoadJobInfo> _info; // UnLoadJob の管理情報 public unsafe UnLoadJob(Allocator alloc) { _target = new NativeList<UnLoadJobTarget<Tdata>>(alloc); _info = new PtrHandle<UnLoadJobInfo>(alloc); _info.Target->job_state = ReadJobState.Completed; } public unsafe void Dispose() { this.DisposeHandle(); _target.Dispose(); _info.Dispose(); } private unsafe void DisposeHandle() { if (_info.Target->alloc_handle) { for (int i = 0; i < _target.Length; i++) _target[i].data.Dispose(); _info.Target->alloc_handle = false; } } public void Clear() { this.DisposeHandle(); _target.Clear(); } public unsafe void AddUnLoadTarget(int file_index, Tdata data, PtrHandle<ReadStateImpl> state_ptr) { _target.Add( new UnLoadJobTarget<Tdata>(file_index, data, state_ptr) ); _info.Target->alloc_handle = true; } public unsafe JobHandle UnLoadAsync() { if(_target.Length > 0) { _info.Target->job_state = ReadJobState.UnLoadJob; _info.Target->job_handle = this.Schedule(); return _info.Target->job_handle; } else { // no action return new JobHandle(); } } public unsafe ReadJobState JobState { get { return _info.Target->job_state; } } public unsafe void Execute() { for (int i = 0; i < _target.Length; i++) _target[i].UnLoad(); _info.Target->job_state = ReadJobState.WaitForCallingComplete; } public unsafe void Complete() { _info.Target->job_handle.Complete(); _info.Target->job_state = ReadJobState.Completed; } }このジョブを1つインスタンス化しておいて、 UnLoad の注文が来たら
UnLoadJob<T>.AddUnLoadTarget(int, T, PtrHandle<ReadStateImpl>)で対象の data を渡し、UnLoadJob<T>.UnLoadAsync()で後始末させます。課題
Burst でもっと早くならない？
いつになるかは不明ですが、公式の案内では
charには対応する予定らしいので、その暁にはもっと早くなるはず。Burst does not support the following types:
- char (this will be supported in a future release)
- string as this is a managed typeライブラリ内部ではASCII範囲の値しか検索、比較していないので、
charをすべてunit16あたりにキャストして、関数ポインタ経由でBurstさせればもっと早くなる可能性は大いにあります。
しかし、公式が対応すると明言していますし、上記の手法で Burst による高速化が特に期待されるホットスポットはTryParse()関数なので、Burst がcharに対応したならユーザーデータクラスのParseLine(line)をまるごと適用したほうがはるかに効果的でしょう。複数のファイルを同時に読ませると途端に遅くなる
デモシーン
/Assets/NativeStringCollections/Demo/Scenes/Demo_AsyncMultiFileManagement.unityで、
AsyncTextFileLoader<T>を使用して n個 のファイルを同時に読み込む指示を出すと、同時に始まった個々のジョブの処理時間が n倍 になり、結局速くなくなるどころか遅延時間の分だけ1個ずつ読ませていたほうがまし、という症状が出ています。
ストレージ <-> メモリ間、あるいは CPU <-> メモリ間の転送速度に引っかかったかとも思いましたが、プロファイラで確認したところメモリ転送負荷になりそうなAsyncReadManager.Read()やNativeList<T>.Add()の処理時間をはじめ、ジョブの処理時間全体がプロファイラ上では 1ジョブの状態とほぼ同じ時間でした。しかしAsyncTextFileReader<T>内部のSystem.Diagnotics.Stopwatchによる処理時間の計測結果、および実時間では一気に動作が遅くなります。
小さなファイルで試すとプロファイラの経過時間と実時間が一致しました。1秒を超えるような長時間のジョブはプロファイラ内の経過時間がバグります。flushingの有無による変化を下記に示します。(Deep Profile)
flushing なし (MaxJobCount = 1)
flushing
LoadJob を flush している場合の、ParseJob 内の各関数の経過時間は下記の通りです。
(数値は 6 Job の総和)
- 0.211 ms File.Read() (間に隙間はあるものの合計 1.0 ms 以下)
- 4751.49 ms ParseText()
- 704.39 ms ParseLinesFromBuffer()
- 3684.18 ms CharaDataParser.ParseLine()
- 165.25 ms ReadOnlyStringEntity.op_Equality()
- 348.70 ms ReadOnlyStringEntity.Slice()
- 904.67 ms StringSplitterExt.Split()
- 1071.26 ms StringParserExt.TryParse()
- 329.31 ms NativeBase64Decoder.GetBytes()
- 552.84 ms NativeStringList.Add()
- 155.91 ms NativeStringList.get_Last
- (156.24 ms others)
- 35.30 ms PostReadProc()
一方で job を1つずつ実行した場合の経過時間の一例は下記のとおりです。
- 0.035 ms File.Read()
- 150.33 ms ParseText()
- 22.24 ms ParseLinesFromBuffer()
- 116.83 ms CharaDataParser.ParseLine()
- 5.11 ms ReadOnlyStringEntity.op_Equality()
- 10.82 ms ReadOnlyStringEntity.Slice()
- 29.93 ms StringSplitterExt.Split()
- 34.11 ms StringParserExt.TryParse()
- 8.65 ms NativeBase64Decoder.GetBytes()
- 17.01 ms NativeStringList.Add()
- 4.66 ms NativeStringList.get_Last
- (6.54 ms others)
- 0.013 ms PostReadProc()
そして各関数の
ParseText()内の相対実行時間を比較すると下表のようになります。
関数名 t[ms]_1Job ratio_1Job t[ms]_6Job ratio_6Job slower/Job File.Read() 0.035 - 0.211 - 1.00x ParseText() 150.33 100.0% 4751.49 100.0% 5.27x ParseLinesFromBuffer() 22.24 14.8% 704.39 14.8% 5.29x CharaDataParser.ParseLine() 116.83 78% 3684.18 77.5% 5.26x ReadOnlyStringEntity.op_Equality() 5.11 3.40% 165.25 3.48% 5.39x ReadOnlyStringEntity.Slice() 10.82 7.20% 348.70 7.34% 5.37x StringSplitterExt.Split() 29.93 19.9% 904.67 19.0% 5.04x StringParserExt.TryParse() 34.11 22.7% 1071.26 22.5% 5.23x NativeBase64Decoder.GetBytes() 8.65 5.75% 329.31 6.90% 6.35x NativeStringList.Add() 17.01 11.3% 552.84 11.6% 5.42x NativeStringList.get_Last 4.66 3.10% 155.91 3.28% 5.58x (others) 6.54 4.35% 156.24 3.29% 3.98x PostReadProc() 0.013 - 35.30 - 452x 表右端の
slower/Jobは6Jobの実行時間を1Jobの実行時間で割った後、さらに6で除して Job 1つあたり何倍遅くなったかの比です。
不思議なことに関数全体にわたって均等に遅くなっています。プロファイラによる観測データの転送でメモリ帯域を食われた可能性も考えましたが、
リリースビルドで同じ 4096 サイズに対し、LoadJob 1つの処理時間は約 6.5 ms (@ 1 Job)-> 約 80 ms (@ 6 Job)
とむしろ比率的にはよりひどい状態で同様の現象が見られます。
また、
PostReadProc()はファイル先頭部分に Base64 で埋め込んだ全データのIDのリストをParseLine()で実際に解析したCharaDataのIDと照合して読み込みエラーがないか確認をするのと、NativeStringList.Add()の繰り返しでバッファが伸長し、各CharaDataの name の参照先が無効になっているはずなのでその再構築をしています。
つまりほぼ計算なしに全データを走査して long の比較とchar配列のコピーをしているだけなので、真にメモリバウンドな処理をするとここまで遅くなるということを示していると考えられます。以上から、やはりキャッシュミスとは異なる現象が起きているように思われ、
自明並列の部分が並列化でなぜ遅くなるのか私の頭では原因がつかめません……
AsyncReadManager自体あまり公式 script reference 以外の情報がなく、そもそもアセットバンドル等のひとまとめにしたバイナリデータをロードするのに用意されたAPIで、完全に用途が違うものを変な使い方している、と言われればそれまでですが……
Unityの中の人に聞ければ解決するかもしれませんが、ちょっとそこまでのお金はないのでだれか解決してくれるとすごくたすかります(他力本願)参考記事
【Unity】ファイルを非同期で読み込んでアンマネージドメモリに展開できるAsyncReadManagerを試してみた
【Unity】NativeArrayについての解説及び実装コードを読んでみる
【Unity】UnsafeUtilityについて纏めてみる
【Unity】BurstCompilerをJobSystem以外でも使いたい
Unity C# Job Systemに参照型を持ち込む
【Unity】スタックトレースを有効にしてNativeArrayのメモリリークを探す
【Unity】UnsafeUtility基礎論【入門者向け】System.Text.Encoding で Shift JIS を使いたい
【C#】Big Size Structが値コピーでつらいならin引数で値コピーしなければいいじゃない！！ ＜ それ本当？
