並び順

ブックマーク数

期間指定

  • から
  • まで

1 - 35 件 / 35件

新着順 人気順

Concurrentの検索結果1 - 35 件 / 35件

タグ検索の該当結果が少ないため、タイトル検索結果を表示しています。

Concurrentに関するエントリは35件あります。 techfeedperformancerust などが関連タグです。 人気エントリには 『SQLite、複数クライアントからの同時書き込みを可能にする「BEGIN CONCURRENT」文を実装へ』などがあります。
  • SQLite、複数クライアントからの同時書き込みを可能にする「BEGIN CONCURRENT」文を実装へ

    SQLite、複数クライアントからの同時書き込みを可能にする「BEGIN CONCURRENT」文を実装へ SQLiteの開発チームは、複数クライアントからの同時書き込みを可能にするBEGIN CONCURRENT文を実装していることを明らかにしました。 これまでSQLiteでは書き込みの同時実行はできず、つねに1つのクライアントだけが書き込み可能でした。 同時書き込み処理は、データベースのジャーナルモードが「wal」(Write-Ahead-log)もしくはwalを改良した「wal2」で、BEGIN CONCURRENT文を実行した場合に可能となります。 どのように同時書き込み処理が行われるのかについては、上記のWebページの説明を引用しましょう。 ロックが延期されることで同時書き込みが可能に まず、書き込み時のロックがCOMMITまで延期されることで同時書き込みが実現されると説明されて

      SQLite、複数クライアントからの同時書き込みを可能にする「BEGIN CONCURRENT」文を実装へ
    • Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 - Qiita

      Concurrent Modeは、現在(2020年3月)実験的機能として公開されているReactの新しいバージョンです。Reactの次のメジャーバージョン(17.x)で正式リリースされるのではないかと思っていますが、確証はありません。なお、React公式からもすでに結構詳細なドキュメントが出ています。 並列モードの導入(実験的機能) Concurrent Modeに適応したアプリケーションを作るためには、従来とは異なる新しい設計が必要となります。筆者はConcurrent Modeを使ったアプリケーションをひとつ試作してみました。この記事から始まる「Concurrent Mode時代のReact設計論」シリーズでは、ここから得た知見を共有しつつ、Concurrent Mode時代に適応したReactアプリケーションの設計を提案します。 なお、Concurrent Modeはまだ正式リリース

        Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 - Qiita
      • GitHub - microsoft/verona: Research programming language for concurrent ownership

        You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

          GitHub - microsoft/verona: Research programming language for concurrent ownership
        • SQLite performance tuning - Scaling SQLite databases to many concurrent readers and multiple gigabytes while maintaining 100k SELECTs per second - phiresky's blog

          SQLite performance tuningScaling SQLite databases to many concurrent readers and multiple gigabytes while maintaining 100k SELECTs per second Jun 26, 2020 • Last Update Jul 31, 2022SQLite is an embedded SQL database. It’s extremely easy to setup, buildable as a single C file with libraries existing for basically all common programming languages. It doesn’t need any server setup or configuration si

          • React Concurrent Mode の概要をおさえる - うどん よこみち

            はじめに この記事は, Introducing Concurrent Mode (Experimental) – React を,和訳しつつ自分の解釈や図を少しだけ足したものになります. 筆者は,そこまで英語が得意ではないので,一部適切でない表現があるかもしれませんがご了承ください. Introducing Concurrent Mode (Experimental) Blocking vs Interruptible Rendering Concurrent Mode は,バージョンコントロール を使って説明します. ここで言うバージョン管理というのは,gitのようなバージョン管理システムです. ブランチを切って作業を行い,他の人が pull できるように作業ブランチをマスターにマージします. バージョン管理の概念が存在する前と後では,開発ワークフローは大きく異なっていました. ブランチ

              React Concurrent Mode の概要をおさえる - うどん よこみち
            • React Concurrent Mode雑感 - しゅみは人間の分析です

              Concurrent Modeのドキュメントを読みました。useEffect によるFetch-on-render から、Suspense によるRender-as-You-Fetch への変化が本質にみえます。 before function ProfilePage() { const [user, setUser] = useState(null); useEffect(() => { fetchUser().then(u => setUser(u)); }, []); if (user === null) { return <p>Loading profile...</p>; } return ( <> <h1>{user.name}</h1> <ProfileTimeline /> </> ); } function ProfileTimeline() { // 省略 } afte

                React Concurrent Mode雑感 - しゅみは人間の分析です
              • Amazon increases NAT Gateway’s capacity to support concurrent connections to a unique destination

                Starting today, you can configure your NAT Gateway to support up to 440,000 concurrent connections to a unique destination by adding multiple IP addresses to same NAT Gateway. A NAT Gateway enables instances in a private subnet to connect to services outside the subnet using the IP address associated with the NAT Gateway. Prior to this launch, you could associate one IP address to your NAT Gateway

                  Amazon increases NAT Gateway’s capacity to support concurrent connections to a unique destination
                • How Much Memory Do You Need to Run 1 Million Concurrent Tasks? | Piotr Kołaczkowski

                  In this blog post, I delve into the comparison of memory consumption between asynchronous and multi-threaded programming across popular languages like Rust, Go, Java, C#, Python, Node.js and Elixir. Some time ago I had to compare performance of a few computer programs designed to handle a large number of network connections. I saw huge differences in memory consumption of those programs, even exce

                  • Concurrent and Parallel Programming - <h1>Joe Armstrong - Erlang and other stuff</h1>

                    • GitHub - pen-lang/pen: The parallel, concurrent, and functional programming language for scalable software development

                      You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

                        GitHub - pen-lang/pen: The parallel, concurrent, and functional programming language for scalable software development
                      • Linux 6.8 Network Optimizations Can Boost TCP Performance For Many Concurrent Connections By ~40% - Phoronix

                        Linux 6.8 Network Optimizations Can Boost TCP Performance For Many Concurrent Connections By ~40% Written by Michael Larabel in Linux Networking on 9 January 2024 at 02:23 PM EST. 76 Comments Beyond the usual new wired/wireless network hardware support and the other routine churn in the big Linux networking subsystem, the Linux 6.8 kernel is bringing some key improvements to the core networking co

                          Linux 6.8 Network Optimizations Can Boost TCP Performance For Many Concurrent Connections By ~40% - Phoronix
                        • React の Concurrent Mode を使ってみる(2020年12月版) - 30歳からのプログラミング

                          React で開発が進められている Concurrent Mode。 まだリリース前の開発中の機能だが、「実験的機能」として提供されており、Experimentalビルドをインストールすることで利用できる。 Experimentalはリリース間の安定性を何も保証しておらず、破壊的変更が行われる可能性がある。Concurrent Mode の動作も、大きく変わる可能性がある。 記事のタイトルに「2020年12月版」と入れたのは、そのため。 公式ドキュメントでは「並列モード」と翻訳されているが、まさに、並列的にレンダリングを行えるようになる。 ネットワークからデータを取得して要素をレンダリングする際に、ユーザーに見えないところで新しいレンダリングの準備をしつつ、データが取得できるまでは古いレンダリングを表示しておく、といったことが可能になる。 この記事では、どういった仕組みでそのようなことが可

                            React の Concurrent Mode を使ってみる(2020年12月版) - 30歳からのプログラミング
                          • How to Perform Concurrent HTTP Requests in Ruby on Rails

                            Ruby MRI does not support parallel CPU bound operations due to the dependency on non-thread safe C extensions. Input/Output operations like HTTP requests, are still a perfectly valid use case for spinning up multiple threads. Read on to learn what tools are available for requests concurrency in Ruby with all their cons and pros. Global Interpreter Lock and blocking I/O Let’s start by describing wh

                              How to Perform Concurrent HTTP Requests in Ruby on Rails
                            • Building Great User Experiences with Concurrent Mode and Suspense – React Blog

                              At React Conf 2019 we announced an experimental release of React that supports Concurrent Mode and Suspense. In this post we’ll introduce best practices for using them that we’ve identified through the process of building the new facebook.com. This post will be most relevant to people working on data fetching libraries for React. It shows how to best integrate them with Concurrent Mode and Suspens

                                Building Great User Experiences with Concurrent Mode and Suspense – React Blog
                              • Properly Testing Concurrent Data Structures

                                Properly Testing Concurrent Data Structures Jul 5, 2024 There’s a fascinating Rust library, loom, which can be used to thoroughly test lock-free data structures. I always wanted to learn how it works. I still do! But recently I accidentally implemented a small toy which, I think, contains some of the loom’s ideas, and it seems worthwhile to write about that. The goal here isn’t to teach you what y

                                • A lock-free, concurrent, generic queue in 32 bits

                                  This article was discussed on Hacker News. While considering concurrent queue design I came up with a generic, lock-free queue that fits in a 32-bit integer. The queue is “generic” in that a single implementation supports elements of any arbitrary type, despite an implementation in C. It’s lock-free in that there is guaranteed system-wide progress. It can store up to 32,767 elements at a time — mo

                                  • GitHub - ms-jpq/coq_nvim: Fast as FUCK nvim completion. SQLite, concurrent scheduler, hundreds of hours of optimization.

                                    You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

                                      GitHub - ms-jpq/coq_nvim: Fast as FUCK nvim completion. SQLite, concurrent scheduler, hundreds of hours of optimization.
                                    • GitHub - xacrimon/dashmap: Blazing fast concurrent HashMap for Rust.

                                      Blazingly fast concurrent map in Rust. DashMap is an implementation of a concurrent associative array/hashmap in Rust. DashMap tries to implement an easy to use API similar to std::collections::HashMap with some slight changes to handle concurrency. DashMap tries to be very simple to use and to be a direct replacement for RwLock<HashMap<K, V>>. To accomplish these goals, all methods take &self ins

                                        GitHub - xacrimon/dashmap: Blazing fast concurrent HashMap for Rust.
                                      • Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する - Qiita

                                        この記事は「Concurrent Mode時代のReact設計論」シリーズの5番目の記事です。 シリーズ一覧 Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 Concurrent Mode時代のReact設計論 (2) useTransitionを活用する Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか Concurrent Mode時代のReact設計論 (4) コンポーネント設計にサスペンドを組み込む Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 Concurrent Mode時代のReact設計論 (

                                          Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する - Qiita
                                        • Migrating Millions of Concurrent Websockets to Envoy - Slack Engineering

                                          Ariane van der Steldt Staff Software Engineer, Site Reliability Slack has a global customer base, with millions of simultaneously connected users at peak times. Most of the communication between users involves sending lots of tiny messages to each other. For much of Slack’s history, we’ve used HAProxy as a load balancer for all incoming traffic. Today, we’ll talk about problems we faced with HAPro

                                            Migrating Millions of Concurrent Websockets to Envoy - Slack Engineering
                                          • Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 - Qiita

                                            この記事は「Concurrent Mode時代のReact設計論」シリーズの6番目の記事です。 シリーズ一覧 Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 Concurrent Mode時代のReact設計論 (2) useTransitionを活用する Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか Concurrent Mode時代のReact設計論 (4) コンポーネント設計にサスペンドを組み込む Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 Concurrent Mode時代のReact設計論 (

                                              Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 - Qiita
                                            • Concurrent, Suspenseの文脈でキャッシュ管理と理想的なデータフェッチを考える (Recoil, Aspida, React Query, GraphQL)

                                              データフェッチで考えられるシナリオ パラメータ無しのGET パラメータ有りのGET キャッシュ保持 キャッシュのinvalidate キャッシュしたデータに対するモデリング ReduxでいうcreateEntityAdapter的な プリフェッチ(+並行リクエスト) SSR対応 APIコールを行わずに初期値を渡せる 最大要件とインタフェースはReact Queryを参考にする すごいオプションあるけど実際に作ってて欲しくなるのは以下 onStart onEnd onSuccess onError refetchOnMount( or staleTime) また、ユーザー体験の観点で以下の要件を満たせると良い 楽観的UI Suspendせずにリフェッチ可能 (画面のチラつき防止) こうして考えたときにReact Queryはほぼ全ての要求を満たしていてさすがだと思う。 キャッシュも効くのでR

                                                Concurrent, Suspenseの文脈でキャッシュ管理と理想的なデータフェッチを考える (Recoil, Aspida, React Query, GraphQL)
                                              • How we tripled max concurrent jobs to boost performance of GitHub Actions

                                                EngineeringHow we tripled max concurrent jobs to boost performance of GitHub ActionsThe GitHub Actions team has done lots of work to improve the performance and resource consumption of Actions on GHES in the past year. GitHub Actions became generally available on GitHub Enterprise Server (GHES) with the 3.0 release about two years ago. Since then, we’ve made many performance improvements to the pr

                                                  How we tripled max concurrent jobs to boost performance of GitHub Actions
                                                • GitHub - bryanp/goru: Concurrent routines for Ruby.

                                                  You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

                                                    GitHub - bryanp/goru: Concurrent routines for Ruby.
                                                  • Transformations on Applicative Concurrent Computations

                                                    When deciding which language to use to solve challenges that require heavy concurrent algorithms, it's hard to not consider Haskell. Its immutable and persistent data structures reduce the introduction of accidental complexity, and the GHC runtime facilitates the creation of thousands of (green) threads without having to worry as much about the memory and performance costs. The epitome of Haskell'

                                                      Transformations on Applicative Concurrent Computations
                                                    • PythonのThread(並列処理)は速度改善効果がないので「concurrent.futures」を使う - SE_BOKUのまとめノート的ブログ

                                                      目次 PythonのThread(並列処理)は速度改善効果がないのか確認 シーケンシャル実行ケースの計測 PythonのThreadを使うケースの時間計測 Threadで速度改善しないのがPythonの仕様 Pythonの並列処理で速度向上できる方法と計測結果 PythonのThread(並列処理)は速度改善効果がないのか確認 PythonのThreadで並列性による速度改善効果を期待しても無駄だと教えてもらったので試してみました。 同じ重たい処理をシーケンシャルに実行するのと、PythonのThreadを使って並列処理するので、どのくらい速度があがるのか?を確認してみます。 シーケンシャル実行ケースの計測 シーケンシャルの処理です。 import time # 単に時間がかかるだけの処理 def killing_time(number): return_list = [] for i i

                                                        PythonのThread(並列処理)は速度改善効果がないので「concurrent.futures」を使う - SE_BOKUのまとめノート的ブログ
                                                      • GitHub - frejs/fre: :ghost: Tiny Concurrent UI library with Fiber.

                                                        You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

                                                          GitHub - frejs/fre: :ghost: Tiny Concurrent UI library with Fiber.
                                                        • SQLite Concurrent Access

                                                          Does SQLite3 safely handle concurrent access by multiple processes reading/writing from the same DB? Are there any platform exceptions to that?

                                                            SQLite Concurrent Access
                                                          • GitHub - zio/zio: ZIO — A type-safe, composable library for async and concurrent programming in Scala

                                                            You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

                                                              GitHub - zio/zio: ZIO — A type-safe, composable library for async and concurrent programming in Scala
                                                            • Concurrent Mode時代のReact設計論 (2) useTransitionを活用する - Qiita

                                                              この記事は「Concurrent Mode時代のReact設計論」シリーズの2番目の記事です。 シリーズ一覧 Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 Concurrent Mode時代のReact設計論 (2) useTransitionを活用する Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか Concurrent Mode時代のReact設計論 (4) コンポーネント設計にサスペンドを組み込む Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 Concurrent Mode時代のReact設計論 (

                                                                Concurrent Mode時代のReact設計論 (2) useTransitionを活用する - Qiita
                                                              • Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか - Qiita

                                                                Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するかJavaScriptTypeScriptReact この記事は「Concurrent Mode時代のReact設計論」シリーズの3番目の記事です。 シリーズ一覧 Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 Concurrent Mode時代のReact設計論 (2) useTransitionを活用する Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか Concurrent Mode時代のReact設計論 (4) コンポーネント設計にサスペンドを組み込む Concurrent Mode時代のReact設計論 (5) トランジション

                                                                  Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか - Qiita
                                                                • Concurrent programming, with examples

                                                                  Mention concurrency and you’re bound to get two kinds of unsolicited advice: first that it’s a nightmarish problem which will melt your brain, and second that there’s a magical programming language or niche paradigm which will make all your problems disappear. We won’t run to either extreme here. Instead we’ll cover the production workhorses for concurrent software – threading and locking – and le

                                                                    Concurrent programming, with examples
                                                                  • SQLite: Begin Concurrent

                                                                    Overview Usually, SQLite allows at most one writer to proceed concurrently. The BEGIN CONCURRENT enhancement allows multiple writers to process write transactions simultanously if the database is in "wal" or "wal2" mode, although the system still serializes COMMIT commands. When a write-transaction is opened with "BEGIN CONCURRENT", actually locking the database is deferred until a COMMIT is execu

                                                                    • IT生涯学習Tech Javaプログラム concurrentパッケージのExecutors

                                                                      concurrentパッケージ concurrentパッケージは、マルチスレッド処理において、各スレッドの状態の監視や管理をし易くした大変便利なパッケージです。 concurrentパッケージは、Java5より導入されたパッケージのため、Java5以降で利用可能です。 2017時点Javaプラットフォームを利用した多くのシステムでは、マルチスレッドと言えばconcurrentパッケージと言えます。 concurrentパッケージでは、大きく分けて次の概念で構成されています。 Thread及びrunnableのrunで実装していた主処理をタスクと呼びます。 タスクは、Executorインターフェイスを頂点とした各種サービス(ThreadPoolExecutor,ScheduledThreadPoolExecutorなど)に処理を並列処理を委譲します。 各種サービスは、サービスに依頼されたタス

                                                                        IT生涯学習Tech Javaプログラム concurrentパッケージのExecutors
                                                                      • Next.js でConcurrent Rendering(Suspense)を試してみた | DevelopersIO

                                                                        はじめに 現在(2022年1月14日)ではReact18のConcurrent RenderingはExperimentalな機能なので、リリースされるころには変わっている可能性がありますが、素振りやコンセプトは体験しておこうと思いまして、GitHubのユーザ検索を作ってみることにしました React18のConcurrent Renderingの概要はこちらを参考にしました。大変わかりやすい説明で感謝です。 ReactのSuspense対応非同期処理を手書きするハンズオン 公式はこちらになります サスペンスを使ったデータ取得(実験的機能) – React サンプルを簡単につくるために、Next.jsを使っています。素のReactでも良いんですが、Routerやらビルド周りを設定するのが面倒なので今回はNext.jsで作ります。 手順 Next.jsのTypeScriptでのプロジェクトを

                                                                          Next.js でConcurrent Rendering(Suspense)を試してみた | DevelopersIO
                                                                        1

                                                                        新着記事