常連

### 前提

Rust で並行処理を行うプログラムを作ろうとしています。

既存の変数を、そのデータをコピーせずに、``Mutex`` や ``Arc`` で包んだり、包みを外したりすることは可能でしょうか？

### 実現したいこと

例えば、次のプログラムを考えます。

```Rust
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {

    let arr = [[0, 1, 2], [3, 4, 5], [6, 7, 8]];
    let lock = Arc::new(Mutex::new(arr)); // <1> ここで、arr をコピーせずに包みたい

    let lock0 = lock.clone();
    let th0 = thread::spawn(move || {
        let mut arr = lock0.lock().unwrap();
        *arr = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
    });

    th0.join().unwrap();
    println!("{:?}", lock.lock().unwrap()); // [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

    // <2> このあと、lock の包みを外して配列データを使用したい
}
```

コメントの ``<1>`` の箇所で、``Arc<Mutex<[[i32; 3]; 3]>>`` 型を宣言していますが、アドレスを調べたところ、``arr`` のデータがコピーされて、``Mutex`` 内に格納されているようです。ここで、``arr`` の所有権を奪い、コピーを行うことなく、``Arc<Mutex<T>>`` で包む方法はありますでしょうか？

それから、コメントの ``<2>`` の箇所で、データをコピーすることなく包みを外す、つまり、再び ``[[i32; 3]; 3]`` 型を生成するような方法はありますでしょうか？

あるいは、配列コピーを行わずに ``Arc`` や ``Mutex`` を使用するならば、スコープの初めから最後まで一貫して包んでおくことしかできないのでしょうか？

ご回答よろしくお願いします。


Rust で既存の変数を Mutex や Arc で包みたい

```rust
fn test(b: String) -> String {
    *(&b)
}

fn main() {
    println!("{}", test("This is the test.".to_string()));
}
```
上記のコードを実行したところ以下のエラーが発生しました。
```terminal
Compiling playground v0.0.1 (/playground)
error[E0507]: cannot move out of a shared reference
 --> src/main.rs:9:5
  |
9 |     *(&b)
  |     ^^^^^ move occurs because value has type `String`, which does not implement the `Copy` trait

For more information about this error, try `rustc --explain E0507`.
error: could not compile `playground` due to previous error
```
これはなぜダメなんでしょうか？
参照を作って外しているだけです。

Rustで参照を作って外すだけでエラーが出る理由

### 前提・実現したいこと
Rustを使って、Shift-JISのCSVを読み込み・加工後、Shift-JIS（cp932・Windows-31J）でCSV出力
したいと考えております。

### 発生している問題・エラーメッセージ

```
UTF-8では出力できているのですが、Shift-JISで出力できず困っております。
まだRustの学び始めで、あまり理解できていない部分が多く申し訳ないのですが、出力できる方法をご教授いただきたく
お願いします。
※色々と検索してみたのですが、Shift-JISでの出力方法を記載しているような情報を見つけることができていません。
※勝手を言って申し訳ございませんが、より高速出力できる方法があれば、ご教授いただけると幸いです。

```

### 該当のソースコード

```Rust
        # 以下の”text”のType
        # encoding_rs_io::DecodeReaderBytes<std::fs::File, std::vec::Vec<u8>>

        let mut outfile =
            BufWriter::new(fs::File::create("test.txt").unwrap());
        let mut reader = BufReader::new(text);

        loop {
            let mut buf = String::new();
            let num_bytes = reader.read_line(&mut buf).unwrap();

            ## UTF-8 → Shift-JISに変換する処理 ##

            if num_bytes == 0 {
                break;
            } else {
                outfile.write(buf.as_bytes()).unwrap();
            }
        }

```

### 試したこと
上記の「UTF-8 → Shift-JISに変換する処理」の部分に以下のようなコードを試してみましたが、
上手くいっておりません。decodeの第一引数には&[u8]をセットしないといけないことは分かったのですが、
この処理をどのように使用すればよいのかがよく分かっていません。

let buf = WINDOWS_31J.decode(buf, DecoderTrap::Strict).unwrap();

・使用したクレート
use std::fs;
use std::fs::File;
use std::*;
use std::io::{self, BufRead, BufReader, BufWriter, Write};
use std::path::Path;
use encoding_rs::SHIFT_JIS;
use encoding_rs_io::DecodeReaderBytesBuilder;


### 補足情報（FW/ツールのバージョンなど）

・Windows10
・rustc 1.57.0

Rust：Shift-JIS（cp932・Windows-31J）でCSV出力

Cのライブラリファイルのみを持っているような状況で、それをRustに組み込んで使いたいがCargoでビルドするときに "-L" フラッグをうまく渡せない

## 環境
- Windows10
- Rust 1.50.0

## 状況
ある装置を制御するためのCライブラリがメーカーに提供されているのですが、ソースコード自体はなくて `.lib`ファイルのみが提供されています。これをRust内で使うために

```bash
.
├── Cargo.lock
├── Cargo.toml
├── c
│   └── lib
│       ├── TUSB16AD.h
│       └── TUSB16AD.lib
└── src
    ├── TUSB16AD.dll
    └── lib.rs
```

というディレクトリ構成でコードを書いています。Cライブラリを使うRust側のコードは `lib.rs` に今のところ書いていて、

```rust
#[link(name = "TUSB16AD", kind = "static")]
extern "C" {
    fn TUSB0216AD_Device_Open(id: i32) -> i32;
    fn TUSB0216AD_Device_Close(id: i32);
}

#[allow(dead_code)]
pub fn device_test() {
    let e: i32;
    unsafe {
        e = TUSB0216AD_Device_Open(1);
    }
    if e != 0 {
        println!("Error code: {}", e);
    }

    unsafe {
        TUSB0216AD_Device_Close(1);
    }
}
```

という動作確認をするだけのコードを書いています。

これをビルドするために、

```bash
rustc -L../c/lib lib.rs
```

として（ビルドを成功させるためだけに）`lib.rs`にmain関数を追加するとうまくビルドできるのですが、`cargo build`すると

```bash
config.toml`
   Compiling mytestproject v0.1.0 (C:\Users\xxx\mytestproject)
error: could not find native static library `TUSB16AD`, perhaps an -L flag is missing?

error: aborting due to previous error

error: could not compile `mytestproject`

To learn more, run the command again with --verbose.
```

となってしまいます。

## 試したこと
`.cargo`ディレクトリ下にconfigファイルを置けるということを知ったので `.cargo`ディレクトリを作ってその下に `config.toml`を作って

```toml
[build]
rustflag = "-L./c/lib"
```
と書いたのですが、ビルドすると同じエラーが出て、

```bash
warning: unused config key `build.rustflag` in `C:\Users\xxx\mytestproject.cargo\config.toml`
```

となります。

どうすれば `cargo build`コマンドでちゃんとビルドできるでしょうか？

CのライブラリをRustに組み込んでCargoでビルドするときに-Lフラッグを渡す方法

## 疑問
https://caddi.tech/archives/1997において「asyncブロックを返す普通のクロージャである。」とあるが、ブロックを返すということがよくわからない。どういう意味でしょうか？
## わかっている点
クロージャはキャプチャした変数を要素に持ちFnOnceやFnMutやFnのトレイトを実装しているなにかだとは分かっていますが、前述した文章と結びつきません
## わからない点
ブロックを返すという言葉の意味
asyncブロックというものの存在
## 調べたこと
https://doc.rust-jp.rs/book-ja/ch13-01-closures.htmlを読んだのですがそれっぽいことが書いてなかった

クロージャがブロックを返すとはどういう意味か

## 質問
rustでプログラミングするのに当たってこれはわかってた方が良いみたいな知識やその身に着け方を教えてください。
TeraTailで質問をしていて、回答者の言ってることが理解できません

## 背景
いろんなサイトでrustの入門のものをいくら読んでも何がわかって何がわかってないかわからないのでpythonのdiscord.pyで作ってたdiscordのbotをrustのserenityで作り直したり、行列計算をrustで実装したりしているのですが、その時にどうしてもわからないことがあって質問してもそれに対する回答があまり理解できないことがある。

## 現状の理解度
C言語をある程度できて、所有権やライフタイムもそこそこ理解できてResultやOptionも慣れてきたかなという具合です。非同期に関してはさっぱりわかってない

## 持っている本
『実践RUSTプログラミング入門』(難しすぎました)

## 余談(?)
モダンな言語すぎて変化が速く、2017年とかの個人ブログ等に書いてあることが今でも通用してふさわしいのか判断することが難しくて辛い

Rustで身に着けるべき前提知識がわからない

# やりたいこと
`rust ndarray`を用いて線形代数や一般的な行列演算を高速に行いたいと思っています。高速に行いたいため、効率よくCPUのコアを使って欲しいと思っています。

# やったこと
`ndarray`と`ndarray_linalg`を用いて、行列演算を試験的逆行列を求めるコードかき、`top`コマンドでCPUの使用率をモニターしました。
使用したコードは以下です。

```rust

use ndarray::{Array2, Array};
use ndarray_linalg::InverseInto;
use ndarray_rand::RandomExt;
use ndarray_rand::rand_distr::Normal;

fn main() {
    let a = Array::random((100000,100000), Normal::new(1.,1.).unwrap());
    let inv_a = a.inv_into().unwrap();
}
``` 

# 結果
CPUの使用率をモニターしたところ100%に張り付いており1コアのみで演算を行っているようにおもいました。

# 調べたこと
[`ndarray_linalg`](https://github.com/rust-ndarray/ndarray-linalg)のソースを読んで調べてみたのですが、逆行列を求めている該当の部分に関しては、[ndarray-linalg/src/solve.rs](https://github.com/rust-ndarray/ndarray-linalg/blob/master/ndarray-linalg/src/solve.rs#L334-L345)の部分だと考えています。
```
impl<A, S> InverseInto for ArrayBase<S, Ix2>
where
    A: Scalar + Lapack,
    S: DataMut<Elem = A> + RawDataClone,
{
    type Output = Self;

    fn inv_into(self) -> Result<Self::Output> {
        let f = self.factorize_into()?;
        f.inv_into()
    }
}
```
とあり、`Scalar`か`Lapack`に`inv_into`が実装されていると考えました。そこで、`Scalar`は[cauchy](https://docs.rs/cauchy/0.3.0/cauchy/)で実装されているもので、`inv_into`が実装されていなさそうだとおもいました。
そのため、`Lapack`で逆行列を求める`inv_into`が実装されていると考えました。
`Lapack`は[/ndarray-linalg/lax/src/lib.rs](https://github.com/rust-ndarray/ndarray-linalg/blob/master/lax/src/lib.rs#L107-L122)に実装されておりました。そのため、`inv_into`は`OperatorNorm_`,
`QR_`,`SVD_`,`SVDDC_`,`Solve_`,`Solveh_`,`Cholesky_`,`Eig_`,`Eigh_`,`Triangular_`,`Tridiagonal_`,`Rcond_`,`LeastSquaresSvdDivideConquer_`のうちのどれかに実装されていそうだと考えました。結局、[`Solve_`](https://github.com/rust-ndarray/ndarray-linalg/blob/master/lax/src/solve.rs)で実装されていると考えました。`inv`の実装しか見つからなかったので`inv_into`の中身がどこにあるのかは結局よくわかりませんでした。

また、`inv`の中身に関しても、Rust初心者なので理解できませんでした。
結局、なぜマルチスレッドで計算できないのかがよくわかりませんでした。

# お答えいただきたいこと

intel_mklを用いて計算しているのであればマルチスレッドで計算されると考えておりました。
なぜマルチスレッドにならないか、どのようにすれば解決するのかを教えていただきたいです。

rust ndarrayの行列演算をマルチスレッドで行いたい

### Rustでグローバル変数に設定データを置きたい

Rustの勉強を少し前から始めました。

Rustのプログラムで全体から参照される設定データを持つ方法を探しています。今回はサンプルですので、コマンドライン引数の0番目と1番目、つまり自分自身の名前と最初の引数を保持することにします。実用面はないかも知れませんが、サンプルということでご了承ください。

練習帳に次のようなコードを書きました。一応コンパイルは通りますが、釈然としない点がいくつかあります。

```
use lazy_static::lazy_static;

lazy_static! {
    static ref argv0: String =
    {
        let args: Vec<String> = std::env::args().collect();
        let s = args[0].clone();
        s
    };
    static ref argv1: String = String::new();
}

fn get_str_ref() -> &'static str {
    &argv0
}

pub(crate) fn init(args: Vec<String>)
{
    println!("{}", get_str_ref());
    // println!("{}", &argv0);
}

```


# 1. init()でグローバル変数を初期化したい

色々調べたところ、Rustではグローバル変数は推奨されていないようです。確かに、野放図にグローバル変数を使うと、どこからアクセスされるかわからないし、バグの温床なのはわかります。

しかし、アプリの起動時など（設定ファイルをロードしたときとか）に値を設定して、あとは基本的に変更しない（読み込みだけ）場合はグローバル変数は便利だと思います。

今回は`Vec<String>`でコマンドライン引数を受け取ることにします。コンパイルを通すために`lazy_static!`の中で`std::env::args().collect()`していますが、これをしたくありません。これは例であって、呼び出し元から情報を渡したり、あるいは何らかの処理をした結果をグローバル変数に入れたいと思います。例えばアプリ名のMD5ハッシュを記録しておきたいなど。

## `lazy_static!`内で初期化したくない、`init()`で初期化したい

わかっていないだけかも知れませんが、`lazy_static!`には外部から情報を渡して初期化できないようですが、それだと使いにくいのです。外部で色々処理をして、その後に`init()`を呼んでグローバル変数を設定したほうが自由度が高く自然だと思うのですが、これはRustの理解が足りないからでしょうか。

## ミュータブルの方がいい場合もある

今回は初期化後はイミュータブル（固定）でよいのですが、今後はミュータブル（値書き換え可能）なグローバル変数を作りたくなるかも知れませんので、この場を借りて同時に質問させてください。

## `lazy_static!`にStringを組み合わせた例が少ない

色々検索したのですが、どういうわけか`lazy_static!`にStringを用いた例があまり見つかりませんでした。


# 2. `lazy_static!`の値を参照したい

今回は単純に`println!()`していますが、値を参照する際によくわからない問題に遭遇しました。

```
fn get_str_ref() -> &'static str {
    &argv0
}
```

という関数を用意した上で

```
pub(crate) fn init(args: Vec<String>)
{
    println!("{}", get_str_ref());
    // println!("{}", &argv0);
}
```

すると値を表示できます。しかしコメントアウトしてあるほうは

```
argv0` cannot be formatted with the default formatter
```

とか

```
`argv0` doesn't implement `std::fmt::Display`
```

というエラーが出ます。エラーの意味はおおよそ見当が付きます（C++の`operator<<`みたいなものでたぶん独自の型で`std::fmt::Display`を実装しておけば`println!()`できるのでしょう）が、`get_str_ref()`はただリファレンスを取得して返すだけの関数です。そして`argv0`はStringなので`println!()`できるはずです。

この2つは何が違うのでしょうか？ただ値を表示するだけなのにリファレンスを取得する関数を書かないといけないのは不便なので原因を知りたいと思います。このリファレンス取得関数は英語の質問サイト（アドレス失念）で見つけました。


# 3. C++との違い

C++の問題点やRustの理念は一応本で読みました。確かにC++は野放図に使うとバグだらけで手に負えないプログラムになるので、Rustのように制約を課して危ないコードはコンパイルできないようにするのは理に適っていると思います。

しかし、グローバルの設定データのようなものは、適切にnamespaceを設定して、その中で変数名も`x`とか`i`みたいな外でも出てきそうな安易な名前を避ければ安全かつ簡単に扱えると思います。C++例：

```
namespace globalSettings
{
    std::string programName;
    std::string workingDirectory;
    std::string userName;
}
```

これならこの値を参照したい、あるいは書き換えたいときに`globalSettings::workingDirectory`を操作するだけです。間違って上書きすることも人並みの注意力があればしないでしょう。

Rustの所有権や借用の理念はわかりますが、この`lazy_static!`については不便すぎではないかと感じていますが、たぶん私がまだRustを始めたばかりで理解が浅いのだと思います。

漠然とした質問になりますが、こういう設定データを扱う場合のRustらしい書き方はありますか？`lazy_static!`を使ったこと自体がC++の考え方をひきずっているのかも知れないと思い、この質問を追加しました。

よろしくおねがいします。

Rustでグローバル変数に設定データを置きたい

### 前提・実現したいこと

ndarray_randを用いて、中身が乱数の行列をf32, f64に対して同じトレイと境界を用いて生成したいと考えています。


### 発生している問題・エラーメッセージ

```
error[E0277]: the trait bound `ndarray_rand::rand_distr::Normal<{float}>: Distribution<T>` is not satisfied
  --> src/linear/sgd.rs:46:69
   |
46 |         let mut weight = Array2::<T>::random((1, input.shape()[0]), Normal::new(1., 1.).unwrap());
   |                                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Distribution<T>` is not implemented for `ndarray_rand::rand_distr::Normal<{float}>`
   |
   = help: the following implementations were found:
             <ndarray_rand::rand_distr::Normal<N> as Distribution<N>>
   = note: required by `ndarray_rand::RandomExt::random`

```

このエラーは自分で実装したtraitがfloatに対応していないというのがエラーの原因だと考えられるのですが、
このトレイとはf32やf64に対応するように実装してあるのにこのようなエラーが出た理由がわかりません

### 該当のソースコード

```rust
use ndarray_linalg::lapack::Lapack;
use ndarray_linalg::types::Scalar;
use ndarray_rand::rand_distr::Float as Float;

trait Type: : Lapack + Scalar + Float {}

impl Type for f32 {}
impl Type for f64 {}

let weight = Array2::random((1, input.shape()[0]), Normal::new(1., 1.).unwrap());
```
多分、f64やf32に対して個別に実装を行えば実装することは可能だとは思いますが、
あまりいい方法とは考えられないためどのように実装すればよいかわかりません。
よろしくお願い致します。

rust ndarrayでf32およびf64に対して乱数の行列を生成する

### 前提・実現したいこと

非同期処理の結果を Future で返す方法に付いて教えて下さい。

1. ２ つのスレッド Main と Worker が存在し、ジョブキューを共有しています。つまり channel の Sender, Receiver で通信しています。
2. Worker はジョブキューを監視して処理が来たらキューから取り出し、Worker スレッド内でそれを実行します。
3. Main スレッドから呼ばれるある関数は、処理をジョブキューに投入して非同期で Worker で実行させ、関数自体は即座に Future を返します。

単に非同期処理を行うだけであれば `async` を使うことができますが、この質問の背景では別の非同期処理と組み合わせているためこのような構成になっています (具体的には `epoll()` や `select()` を使うケースのように Worker スレッドがイベントループしている想定です)。

### 発生している問題・エラーメッセージ

後述のソースコードの `enqueue()` 関数の返値を `Future<R>` にして `let result = exec();` の `result` を非同期で取得するにはどうしたら良いでしょうか? 最終的には以下のように記述できるようにしたいと思っています。

```rust
let now = euqueue(&sender, move || SystemTime::now()).await;
```

### 該当のソースコード

```rust
use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread::{sleep, spawn};
use std::time::{Duration, SystemTime};
use std::fmt::Debug;

type TASK = Box<dyn FnMut() + Send>;

fn main() {
  let (sender, receiver) = channel::<TASK>();
  spawn(move || event_loop(receiver));
  loop {
    sleep(Duration::from_secs(1));
    euqueue(&sender, move || SystemTime::now());
  }
}

fn euqueue<R, F>(sender: &Sender<TASK>, mut exec: F) where F: FnMut() -> R + Send, F: 'static, R:Debug {
  sender.send(Box::new(move || {
    let result = exec();   // How to return this result as Future for function enqueue()?
    println!("task has been executed with: {:?}", result);
  })).unwrap();
}

fn event_loop(receiver: Receiver<TASK>) {
  loop {
    let mut exec = receiver.recv().unwrap();
    exec();
  }
}
```

### 補足情報（FW/ツールのバージョンなど）

```
> rustc --version
rustc 1.48.0 (7eac88abb 2020-11-16)
```

Rust: 別のスレッドでの処理結果を Future にするには?

### 前提・実現したいこと

2つの同じサイズのvectorの同一性の比較としてthreadを作ったのですが，想定に反して速くありません。何が問題なのかお分かりになる方がいらっしゃれば教えてください。
構造は至って単純です。
・elapsed_time_dblは時間計測用テンプレート関数
・is_eq_ob　スレッド管理クラス ,!=を見つけたときのスレッド中止用フラッグとしてatomicを使用。結果判定返却用として兼用。

### 該当のソースコード

```C++
#include <thread>
#include <chrono>
#include <vector>
using namespace std;
template<class TimePoint>
double elapsed_time_dbl(const std::string& msg, const TimePoint& start) {
    auto end=std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> fp_ms = end-start;
    std::cout << msg <<" : " << fp_ms.count()<<" ms\n";
    return fp_ms.count();
}
class is_eq_ob{
    int size;
    const vector<int>& m_a;
    const vector<int>& m_b;
    atomic<bool> m_loop_end;
public:
    is_eq_ob(const vector<int>&a, const vector<int>&b):
    m_a{a},m_b{b},m_loop_end{false},size{(int)a.size()}{}
 
    void comp_thread(int st, int count ){
        for(int i=0;i < count;i++){
            if(m_loop_end.load())
                return ;
            if( m_a[st+ i] != m_b[st+ i] ){
                m_loop_end.store(true);
                return ;
            }
        }
    }
    bool go(){
        
        vector<thread> th_s;
        int div = 10;
        ///divの数のスレッド生成,sizeをdiv数で分割してブロックごとに処理
        for(int d=0;d < div;d++){
            int start = size * d/div;//スレッドに渡す開始位置
            int end   = (d==div-1) ? size: size*(d+1)/div;//スレッドに渡す終了位置
            thread a(&is_eq_ob::comp_thread,this, start, end - start);
            th_s.push_back( move(a) );
        }
        
       for(auto& th: th_s)
           th.join();
        
        return !m_loop_end.load();
    }
};


int main(){
   
    vector<int> a(1000,0);
    vector<int> b(1000,0);
    //a[100]=1;
    
    auto start=std::chrono::high_resolution_clock::now();
    cout << (a==b)<<'\n';
    elapsed_time_dbl("a==b", start);
    
    is_eq_ob is_eq(a,b);
    start=std::chrono::high_resolution_clock::now();
    cout << is_eq.go() <<'\n';
    elapsed_time_dbl("is_eq_ob", start);
    return 0;
}
```

### 試したこと
結果は次のように常にスレッドの方が遅くなります。
1
a==b : 0.064569 ms
1
is_eq_ob : 0.37863 ms

マルチスレッドでループを最適化してみたが速くない

### 前提・実現したいこと

vimで複数行を選択して一括で「連続で」上下移動させるscriptを作りたいのですがうまく動かず困っています。

### 試したこと
下記のコードを試し、コメントアウトしているところが本命です。

複数行をビジュアルモードで選択した後、試しにfunctionを使わず
vnoremap <S-Down> xp<S-v> 5+j
を使うと、5行選択がキープされたまま連続で下にシフトさせることができました。
一方コメントアウト１を外してfunctionを機能させるとjとg:rowsがうまく連結してくれず
選択行数の選択をキープできません。
念のためコメントアウト２を試したら選択行数が返ってきたのでfunctionは問題ないと思っています。

```vim
vnoremap <S-Down> xp<S-v> 5+j
"1. vnoremap <S-Down> xp<S-v> :Rows_count()<CR> g:rows+j
"2. vnoremap <S-Down>  :call Rows_count()<CR> :echo g:rows<CR>

function Rows_count()
    let g:rows = line("'>") - line("'<") + 1 "選択行数を取得
    return g:rows
endfunction

```

結局のところ、map上で変数＋jを実現するにはどうすればよいかという質問で解決します。
スクリプト・mapを使った別の代替案でも構いません。
ご回答いただけると幸いです。

なおカット＆ペーストすればよいのは分かっていますが、勉強かねてスクリプトもしくはmapを作ることを主眼としています。

vimで複数行一括移動させるスクリプト・mapを作りたい

iosアプリをrustで開発した場合は
c++を使って異言語間インタフェース FFI をしないといけないみたいなのですが

そうするとc++のコードに変換されるのでしょうか
そうしたらやはりパフォーマンスなどはｃ++のパフォーマンスになってしまうのでしょうか?

異言語間インタフェース FFI とは

別のOSに対応させたくクロスコンパイルを実行したいのですが

その場合は何か処理速度が低下するなどのデメリットもあるのでしょうか？