OpenRaft 在交易撮合引擎中的应用

OpenRaft实操分享(撮合引擎场景) 由于工作需要,一直对原子多播应用有非常浓厚的兴趣。通过一段时间的技术选型。我们非常幸运的得到了databend社群的热心支持。我也想通过我们的实际工作,对Openraft的未来应用尽一些微薄之力。 我的实践的上一篇文章反应了我们的选型过程,有兴趣的人可以看一下。 Raft in Rust (原子多播+撮合引擎)_Raymond-Shen的博客-优快云博客前言Raft作为一个分布式协同算法,这是原子多播的一个非常重要的视线。今天也得到了广泛的应用。当前情况下,我们为了更好的实现一个快速的撮合引擎,我们进 阅读详情

前言

由于工作需要,一直对原子多播应用有非常浓厚的兴趣。通过一段时间的技术选型。我们非常幸运的得到了 Openraft 实操分享 Databend 社区的热心支持。我也想通过我们的实际工作,对 Openraft 的未来应用尽一些微薄之力。

Openraft 是一个 Raft 的改进版(包括优化选举冲突, 解决网络抖动对 leadership 的影响), 它在 Databend 中为 db, table 等元数据提供分布式存储和强一致读写, 为 databend 的云端数据库集群提供事务性保证.

我的实践的上一篇文章反应了我们的选型过程,有兴趣的人可以看一下。Raft in Rust (原子多播+撮合引擎)这篇文章更多的是想说明我们在使用 OpenRaft 的实际问题,并且通过我们的实现,揭秘 OpenRaft 的一些机制。


代码仓库

大家在使用 OpenRaft 的时候,我相信很多人都查看了手册: Getting Started - openraftThe openraft user guide.

当然,这是一个非常优秀的手册。我们从这个手册里,会学习到如何使用 OpenRaft 实现自己的应用。而且,openraft/example-raft-kv 这个例子确实能够很好的说明如何实现一个简单的应用。但是,这个例子是使用的内存来做持久化实现。当然内存不会真正做持久化,所以很容易在节点退出后,丢失状态。而我们真正需要的示例是一个能够持久化的例子。

另外一个实例就是 databend/metasrv 而这个示例里面,我们可以看到一个完整的 metadata 存储服务的实现。实际上,metasrv 本身是一个类似于 etcd 的 kv 存储。存储整个 databend 集群的 metadata。这个示例里面,metasrv 使用了 sled 作为底层存储。sled 既存储 log,也存储 statemachine 的状态。这个例子,statemachine 所有的更新都直接在 sled 存储里通过 sled 的事物完成了。所以,对于如何存储 snapshot 这个问题,我们并不太容易看清楚。所以 snapshot 的产生和传递主要是在节点间同步的时候使用。

这里,大家可以看到我们开放的源代码。虽然这个示例是基于 example-raft-kv 示例,没有达到 metasrv 的生产强度。但是我们还是非常全面的表现出了 openraft 对 log, snapshot 处理的行为和能力。

GitHub - raymondshe/matchengine-raft


应用场景

和 metasrv 的场景不同。我们需要我们的 statemachine 尽量在内存里面更新,尽量少落盘。虽然 sled 本地落盘的速度也很快,但是内存操作的速度会更快。所以,我们基本上就是这样进行操作的。

  总体设计图

所以在这个图里面,大家可以看到日志是通过 sled 进行存储的。而这些日志由于通过 Raft 协议,实际上他们在每台机器上的顺序是一致的。 所以,不同的 matchengine-raft 实例,在相同的日志流情况下,对状态机的操作就是一致的。所以,不管我们从哪一个日志开始写 snapshot,通过加载 snapshot 并且回放后续的日志,我们都可以恢复到最新状态。

按照设计图中显示,当前 StateMachine 的状态是处理了第 9 个日志里的消息。 这时候,系统保存了所有的消息到 sled。并且在第 3 个消息的时候落盘了一次 snapshot,并且在低 6 个消息的时候落盘了一次 snapshot。 如果这台机器当机,我们是可以从编号为3的 snapshot 恢复状态机,并且继续处理 3,4,5,6,7,8,9 这 6 条消息来恢复当前状态。 当然,我们也可以从编号为 6 的 snapshot 恢复状态机,并且继续处理 7,8,9 这 3 条消息来恢复当前状态。

当然我们可以选择多少个消息进行一次落盘。当然落盘的次数越多越可靠,但是性能影响比较大。好在 snapshot 的生成和落盘是异步的方式做的。

有兴趣的朋友可以看一下 akka 的 EventSroucing 模式。这种模式和 Raft 单节点非常相像。不同的是 OpenRaft 强调多实例一致性,而 Akka 则提供了非常多的方式来存储 Log(Journal) 和 Snapshot.


实现细节

谈到实现细节。我们还是回到官方文档 geting-started 来。我们也按照这个文档的顺序进行说明。

Raft 对于从应用开发着的角度,我们可以简化到下面的这张图里。Raft 的分布式共识就是要保证驱动状态机的指令能够在 Log 里被一致的复制到各个节点里。

Raft 有两个重要的组成部分:

  • 如何一致的在节点之间复制日志
  • 并且在状态机里面如何消费这些日志

基于 OpenRaft 实现我们自己的 Raft 应用其实并不复杂,只需要一下三部分:

  • 定义好客户端的请求和应答
  • 实现好存储 RaftStore 来持久化状态
  • 实现一个网络层,来保证 Raft 节点之间能相互传递消息。

好,那我们就开始吧:

1. 定义好客户端的请求和应答


请求有可能是客户端发出的驱动 Raft 状态机的数据,而应答则是 Raft 状态机会打给客户端的数据。

请求和应答需要实现 AppData 和 AppDataResponse 这里,我们的实现如下:

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ExampleRequest {
    Set { key: String, value: String },
    Place { order: Order },
    Cancel { order: Order}
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ExampleResponse {
    pub value: Option<String>,
}

这两个类型完全是应用相关的,而且和 RaftStrage 的状态机实现相关。

  1. 这里,Set 是 example-raft-kv 原示例就有的命令。
  2. 大家也注意到了,命令都是对状态机有驱动的命令。也就是会对状态机状态造成改变的命令。如果我们需要取状态机内部数据的值返回给客户端。我们大可不必定义到这里。

2. 实现 RaftStorage

这是整个项目非常关键的一部分。

只要实现好 trait RaftStorage,我们就把数据存储和消费的行为定义好。RaftStoreage 可以包装一个像 RocksDB, Sled 的本地 KV 存储或者远端的 SQL DB。

RaftStorage 定义了下面一些 API

  • 读写Raft状态,比方说 term,vote (term:任期,vote:投票结果)
fn save_vote(vote:&Vote)
fn read_vote() -> Result<Option<Vote>>
  • 读写日志
fn get_log_state() -> Result<LogState> fn try_get_log_entries(range) -> Result<Vec<Entry>>
fn append_to_log(entries)
fn delete_conflict_logs_since(since:LogId)
fn purge_logs_upto(upto:LogId)
  • 将日志的内容应用到状态机
fn last_applied_state() -> Result<(Option<LogId>,Option<EffectiveMembership>)>
fn apply_to_state_machine(entries) -> Result<Vec<AppResponse>>
  • 创建和安装快照(snapshot) 
fn build_snapshot() -> Result<Snapshot> fn get_current_snapshot() -> Result<Option<Snapshot>>
fn begin_receiving_snapshot() -> Result<Box<SnapshotData>>
fn install_snapshot(meta, snapshot)

在 ExampleStore, 这些内存化存储行为是非常明确简单的。而我们不是要真正落盘了吗?那我们就看一下 matchengine-rust 是怎么实现的。

这里是 matchengine-raft/src/store

接口实现方式
Raft状态sled 存储,使用专门的 key 来读写 raft 状态。
日志sled 存储,使用 log_index 来唯一标识一个 Log Entity
应用状态机状态机里面一部分是业务数据,但是一部分是 raft 的数据。业务数据主要是订单薄。   
快照快照完全是通过文件进行存储的,而且文件的名字就保留了快照的全部 meta 信息。

我们说明一些设计要点

ExampleStore 的数据

ExchangeStore 里面主要是包含下面的成员变量。

#[derive(Debug)]
pub struct ExampleStore {

    last_purged_log_id: RwLock<Option<LogId<ExampleNodeId>>>,

    /// The Raft log.

    pub log: sled::Tree,
    
    /// The Raft state machine.
    pub state_machine: RwLock<ExampleStateMachine>,

    /// The current granted vote.
    vote: sled::Tree,

    snapshot_idx: Arc<Mutex<u64>>,

    current_snapshot: RwLock<Option<ExampleSnapshot>>,

    config : Config,

    pub node_id: ExampleNodeId,

}

帮助我们落盘的成员主要是 log, vote。而需要产生 snapshot 进行落盘的所有内容都在 state_machine.

  1. last_purged_log_id: 这是最后删除的日志ID。删除日志本身可以节约存储,但是,对我们来讲,我了保证数据存储的安全。在删除日志之前,我们必须有这条日志 index 大的 snapshot 产生。否则,我们就没有办法通过 snapshot 来恢复数据。

  2. log: 这是一个 sled::Tree,也就是一个 map。如果看着部分代码的话,我们就可以清楚的明白 log 对象的结构。key 是一个log_id_index的 Big Endian 的字节片段。value 是通过 serd_json 进行序列化的内容。

    #[tracing::instrument(level = "trace", skip(self, entries))]
    async fn append_to_log(
        &mut self,
        entries: &[&Entry<ExampleTypeConfig>],
    ) -> Result<(), StorageError<ExampleNodeId>> {

        let log = &self.log;
        for entry in entries {
            log.insert(entry.log_id.index.to_be_bytes(), IVec::from(serde_json::to_vec(&*entry).unwrap())).unwrap();
        }
        Ok(())
    }

  1. state_machine: 这里就是通过日志驱动的所有状态的集合。
#[derive(Serialize, Deserialize, Debug, Default, Clone)]pub struct ExampleStateMachine {

    pub last_applied_log: Option<LogId<ExampleNodeId>>,

    // TODO: it should not be Option.
    pub last_membership: EffectiveMembership<ExampleNodeId>,

    /// Application data.
    pub data: BTreeMap<String, String>,

    // ** Orderbook
    pub orderbook: OrderBook,

}

StateMachine 里面最重要的数据就是 orderbook 这部分就是撮合引擎里面重要的订单表。存放买方和卖方的未成交订单信息。这是主要的业务逻辑。 data 这部分是原来例子中的 kv 存储。我们还在这里没有删除。

这里 last_applied_log, last_menbership 这些状态和业务逻辑没有太大关系。所以,如果您要实现自己的 StateMachine。 还是尽量和例子保持一致。主要是因为这两个状态是通过apply_to_state_machine()这个接口更新。也正好需要持久化。如果需要进一步隐藏 Raft 的细节,我们还是建议openraft能将这两个状态进一步进行隐藏封装。

对state_machine的落盘操作主要集中在这里:store/store.rs。有兴趣的可以看一下。这里面比较有意思的问题是orderbook本身无法被默认的serde_json序列化/反序列化。所以我们才在 matchengine/mod.rs 加了这段代码:

pub mod vectorize {
    use serde::{Deserialize, Deserializer, Serialize, Serializer};
    use std::iter::FromIterator;

    pub fn serialize<'a, T, K, V, S>(target: T, ser: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
        T: IntoIterator<Item = (&'a K, &'a V)>,
        K: Serialize + 'a,
        V: Serialize + 'a,
    {
        let container: Vec<_> = target.into_iter().collect();
        serde::Serialize::serialize(&container, ser)
    }

    pub fn deserialize<'de, T, K, V, D>(des: D) -> Result<T, D::Error>
    where
        D: Deserializer<'de>,
        T: FromIterator<(K, V)>,
        K: Deserialize<'de>,
        V: Deserialize<'de>,
    {
        let container: Vec<_> = serde::Deserialize::deserialize(des)?;
        Ok(T::from_iter(container.into_iter()))
    }
}

/// main OrderBook structure
#[derive(Clone, Default, Serialize, Deserialize, Debug)]
pub struct OrderBook {
    #[serde(with = "vectorize")]
    pub bids: BTreeMap<BidKey, Order>,
    #[serde(with = "vectorize")]
    pub asks: BTreeMap<AskKey, Order>,
    pub sequance: u64,
}
  1. vote: 就是对最后一次vote的存储。具体请看, 这段代码倒不是因为这段代码有多重要,只是由于代码比较简单,看可以少些一些说明:
#[tracing::instrument(level = "trace", skip(self))]
    async fn save_vote(&mut self, vote: &Vote<ExampleNodeId>) -> Result<(), StorageError<ExampleNodeId>> {
        self.vote.insert(b"vote", IVec::from(serde_json::to_vec(vote).unwrap())).unwrap();
        Ok(())
    }

    async fn read_vote(&mut self) -> Result<Option<Vote<ExampleNodeId>>, StorageError<ExampleNodeId>> {
        let value = self.vote.get(b"vote").unwrap();
        match value {
            None => {Ok(None)},
            Some(val) =>  {Ok(Some(serde_json::from_slice::<Vote<ExampleNodeId>>(&*val).unwrap()))}
        }
    }

但是这儿确实有个小坑,之前我没有注意到vote需要持久化,开始调试的时候产生了很多问题。知道找到 Openraft 作者 Zhang Yanpo 才解决。 也是出发我想开源这个 openraft 文件持久化实现的诱因吧。感谢 Zhang Yanpo, 好样的。

  1. 其他的成员变量其实没什么太好说的了。和原例子一样。

对日志和快照的控制

日志,快照相互配合,我们可以很好的持久化状态,并且恢复最新状态。多久写一次快照,保存多少日志。在这里我们使用了下面的代码。

let mut config = Config::default().validate().unwrap();
    config.snapshot_policy = SnapshotPolicy::LogsSinceLast(500);
    config.max_applied_log_to_keep = 20000;
    config.install_snapshot_timeout = 400;

强烈建议大家看一下 Config in openraft::config - Rust

重点看 snapshot_policy, 代码里可以清楚的标识,我们需要 500 次 log 写一次快照。也就是 openraft 会调用 build_snapshot() 函数创建 snapshot。原示例里,snapshot 只是在内存里保存在 current_snapshot 变量里。而我们需要真实的落盘。请注意这段代码的 self.write_snapshot()

#[async_trait]
impl RaftSnapshotBuilder<ExampleTypeConfig, Cursor<Vec<u8>>> for Arc<ExampleStore> {
    #[tracing::instrument(level = "trace", skip(self))]
    async fn build_snapshot(
        &mut self,
    ) -> Result<Snapshot<ExampleTypeConfig, Cursor<Vec<u8>>>, StorageError<ExampleNodeId>> {
        let (data, last_applied_log);

        {
            // Serialize the data of the state machine.
            let state_machine = self.state_machine.read().await;
            data = serde_json::to_vec(&*state_machine)
                .map_err(|e| StorageIOError::new(ErrorSubject::StateMachine, ErrorVerb::Read, AnyError::new(&e)))?;

            last_applied_log = state_machine.last_applied_log;
        }

        let last_applied_log = match last_applied_log {
            None => {
                panic!("can not compact empty state machine");
            }
            Some(x) => x,
        };

        let snapshot_idx = {
            let mut l = self.snapshot_idx.lock().unwrap();
            *l += 1;
            *l
        };

        let snapshot_id = format!(
            "{}-{}-{}",
            last_applied_log.leader_id, last_applied_log.index, snapshot_idx
        );

        let meta = SnapshotMeta {
            last_log_id: last_applied_log,
            snapshot_id,
        };

        let snapshot = ExampleSnapshot {
            meta: meta.clone(),
            data: data.clone(),
        };

        {
            let mut current_snapshot = self.current_snapshot.write().await;
            *current_snapshot = Some(snapshot);
        }

        self.write_snapshot().await.unwrap();

        Ok(Snapshot {
            meta,
            snapshot: Box::new(Cursor::new(data)),
        })
    }
}

这下我们有了 snapshot,当然 snapshot 一方面可以用来在节点之间同步状态。 另一方面就是在启动的时候恢复状态。而 openraft 的实现非常好。实际上恢复状态只需要回复到最新的 snapshot 就行。只要本地日志完备,openraft 会帮助你调用 apply_to_statemachine() 来恢复到最新状态。所以我们就有了 restore() 函数。

#[async_trait]
impl Restore for Arc<ExampleStore> {
    #[tracing::instrument(level = "trace", skip(self))]
    async fn restore(&mut self) {
        tracing::debug!("restore");
        let log = &self.log;

        let first = log.iter().rev()
        .next()
        .map(|res| res.unwrap()).map(|(_, val)|
            serde_json::from_slice::<Entry<ExampleTypeConfig>>(&*val).unwrap().log_id);

        match first {
            Some(x) => {
                tracing::debug!("restore: first log id = {:?}", x);
                let mut ld = self.last_purged_log_id.write().await;
                *ld = Some(x);
            },
            None => {}
        }

        let snapshot = self.get_current_snapshot().await.unwrap();

        match snapshot {
            Some (ss) => {self.install_snapshot(&ss.meta, ss.snapshot).await.unwrap();},
            None => {}
        }
    }
}

大家注意一下 snapshot 的操作。当然,在这里,我们也恢复了 last_purged_log_id。

当然 store 这个函数会在 ExampleStore 刚刚构建的时候调用。

   // Create a instance of where the Raft data will be stored.
   let es = ExampleStore::open_create(node_id);

   //es.load_latest_snapshot().await.unwrap();

   let mut store = Arc::new(es);

   store.restore().await;

如何确定 RaftStorage 是对的

请查阅 Test suite for RaftStorage, 如果通过这个测试,一般来讲, OpenRaft 就可以使用他了。

#[test]
pub fn test_mem_store() -> anyhow::Result<()> { openraft::testing::Suite::test_all(MemStore::new) }

RaftStorage 的竞争状态

在我们的设计里,在一个时刻,最多有一个线程会写状态,但是,会有多个线程来进行读取。比方说,可能有多个复制任务在同时度日志和存储。

实现必须保证数据持久性

调用者会假设所有的写操作都被持久化了。而且 Raft 的纠错机制也是依赖于可靠的存储。


3. 实现 RaftNetwork

为了节点之间对日志能够有共识,我们需要能够让节点之间进行通讯。trait RaftNetwork就定义了数据传输的需求。RaftNetwork的实现可以是考虑调用远端的 Raft 节点的服务

pub trait RaftNetwork<D>: Send + Sync + 'static where D: AppData {
    async fn send_append_entries(&self, target: NodeId, node:Option<Node>, rpc: AppendEntriesRequest<D>) -> Result<AppendEntriesResponse>;
    async fn send_install_snapshot( &self, target: NodeId, node:Option<Node>, rpc: InstallSnapshotRequest,) -> Result<InstallSnapshotResponse>;
    async fn send_vote(&self, target: NodeId, node:Option<Node>, rpc: VoteRequest) -> Result<VoteResponse>;
}

ExampleNetwork 显示了如何调用传输消息。每一个 Raft 节点都应该提供有这样一个 RPC 服务。当节点收到 raft rpc,服务会吧请求传递给 raft 实例,并且通过 raft-server-endpoint 返回应答。

在实际情况下可能使用 Tonic gRPC 是一个更好的选择。 databend-meta 里有一个非常好的参考实现。

在我们的 matchengen-raft 实现里,我们解决了原示例中大量重连的问题。

  1. 维护一个可服用量的 client

这段代码在:network/raft_network_impl.rs

     let clients = Arc::get_mut(&mut self.clients).unwrap();
     let client = clients.entry(url.clone()).or_insert(reqwest::Client::new());
  1. 在服务器端引入keep_alive

这段代码在:lib.rs

// Start the actix-web server.
let server = HttpServer::new(move || {
    App::new()
        .wrap(Logger::default())
        .wrap(Logger::new("%a %{User-Agent}i"))
        .wrap(middleware::Compress::default())
        .app_data(app.clone())
        // raft internal RPC
        .service(raft::append)
        .service(raft::snapshot)
        .service(raft::vote)
        // admin API
        .service(management::init)
        .service(management::add_learner)
        .service(management::change_membership)
        .service(management::metrics)
        // application API
        .service(api::write)
        .service(api::read)
        .service(api::consistent_read)
}).keep_alive(Duration::from_secs(5));

这样的改动确实是对性能有一些提升。但是真的需要更快的话,我们使用 grpc,甚至使用 reliable multicast,比方说 pgm。


4. 启动集群

由于我们保留了之前的 key/value 实现。所以之前的脚本应该还是能够工作的。而且之前的 key/value 有了真正的存储。

为了能够运行集群:

  • 启动三个没有初始化的 raft 节点;

  • 初始化其中一台 raft 节点;

  • 把其他的 raft 节点加入到这个集群里;

  • 更新 raft 成员配置。 example-raft-kv 的 readme 文档里面把这些步骤都介绍的比较清楚了。

  • 下面两个测试脚本是非常有用的: test-cluster.sh 这个脚本可以简练的掩饰如何用 curl 和 raft 集群进行交互。在脚本里,您可以看到所有 http 请求和应答。

test_cluster.rs 这个 rust 程序显示了怎么使用 ExampleClient 操作集群,发送请求和接受应答。

这里我们要强调的是,在初始化 raft 集群的时候。我们需要上述的过程。如果集群已经被初始化,并且我们已经持久化了相应的状态 (menbership, vote, log) 以后,再某些节点退出并且重新加入,我们就不需要再过多干预了。

在使用 metasrv 启动 meta service 的时候,我也遇到了相同的情况。所以还是要先启动一个single node以保证这个节点作为种子节点被合理初始化了。

Deploy a Databend Meta Service Cluster | Databend

为了更好的启动管理集群,我们在项目里添加了 test.sh。用法如下:

./test.sh <command> <node_id>

我们可以在不同阶段调用不同的命令。大家有兴趣的话可以看一下代码。这部分是主程序部分,包含了我们实现的所有命令。

echo "Run command $1"
case $1 in
"place-order")
    place_order $2
    ;;
"metrics")
    get_metrics $2
    ;;

"kill-node")
    kill_node $2
    ;;
"kill")
    kill
    ;;
"start-node")
    start_node $2
    ;;
"get-seq")
    rpc 2100$2/read  '"orderbook_sequance"'
    ;;
"build-cluster")
    build_cluster $2
    ;;
"change-membership")
	change_membership $2
    ;;

"clean")
    clean
    ;;
  *)
    "Nothing is done!"
    ;;
esac

未来的工作

当前我们实现的 matchengine-raft 只是为了示例怎么通过raft应用到撮合引擎这样一个对性能,稳定性,高可用要求都非常苛刻的应用场景。通过 raft 集群来完成撮合引擎的分布式管理。我们相信真正把这个玩具撮合引擎推向产品环境,我们还是需要进行很多工作:

  1. 优化序列化方案,serd_json 固然好,但是通过字符串进行编解码还是差点儿意思。至少用到 bson 或者更好的用 protobuf, avro等,提高编解码速度,传输和存储的开销。
  2. 优化 RaftNetwork, 在可以使用 multi-cast 的情况下使用 pgm,如果不行,可以使用 grpc。
  3. 撮合结果的分发。这部分在很多情况下依赖消息队列中间件比较好。
  4. 增加更多的撮合算法。这部分完全是业务需求,和 openraft 无关。我们就不在这个文章里讨论了。
  5. 完善测试和客户端的调用。
  6. 完善压测程序,准备进一步调优。

结论

通过这个简单的小项目,我们:

  1. 实现了一个简单的玩具撮合引擎。
  2. 验证了 OpenRaft 在功能上对撮合引擎场景的支持能力。
  3. 给 OpenRaft 提供了一个基于 sled KV 存储的日志存储的参考实现。
  4. 给 OpenRaft 提供了一个基于本地文件的快照存储的参考实现。

给大家透露一个小秘密,SAP 也在使用 OpenRaft 来构建关键应用。大家想想,都用到 Raft 协议了,一定是非常重要的应用。

对于 databend 社区的帮助,我表示由衷的感谢。 作为一个长期工作在软件行业一线的老程序猿,看到中国开源软件开始在基础构建发力,由衷的感到欣慰。也希望中国开源社群越来越好,越来越强大,走向软件行业的顶端。

作者信息:沈勇 Decisive Density  CTO

关于 Databend

Databend 是一款开源、弹性、低成本,基于对象存储也可以做实时分析的新式数仓。期待您的关注,一起探索云原生数仓解决方案,打造新一代开源 Data Cloud。

 文章首发于公众号:Databend

 

CppTrader:用于构建交易平台的高性能组件,例如超快速匹配引擎、订单簿处理器 CppTrader C++ Trader 是一组用于构建高性能交易平台的组件: 超快速匹配引擎 订单簿处理器 纳斯达克 ITCH 处理程序 内容 市场经理(积极的优化版本) 特征 跨平台(Linux、OSX、Windows) 基准 例子 测试 Doxygen API 文档 持续集成( Travis CI , AppVeyor ) 要求 Linux (binutils-dev uuid-dev) 操作系统 视窗 10 制作 海湾合作委员会 吉特 吉尔 Python3 可选的: 铛 克莱恩 赛格温 MSYS2 明威 视觉工作室 怎么建? 安装gil(git链接)工具 pip3 install gil 设置存储库 git clone https://github.com/chronoxor/CppTrader.git cd CppTrader gil update 立即下载

相关推荐

高并发撮合系统

币圈的撮合系统,高并发,使用了字典哈希表,以及跳跃表进行撮合。

7个开源交易撮合引擎

7个开源交易撮合引擎 如果你希望按照自己的需求打造金融交易平台,那么应当选择合适的交易撮合 引擎进行二次开发而不是基于完整的交易平台实现进行修改。本文将介绍 10个采用不同语言开发的开源的撮合引擎,你可以根据自己的需要选择。 1、Liquibook 开发语言:C++ 源代码:https://github.com/enewhuis/liquibook Liquibook是OC...

周红伟讲AI 9174

撮合交易系统

一款免费的撮合系统,可实现商品买卖,测试使用

【Java教程】Day24-07 Spring Cloud开发:设计交易引擎——设计撮合引擎

在证券交易系统中,撮合引擎是实现买卖盘成交的关键组件。在本教程中,我们将通过分析撮合引擎的工作原理,设计并实现一个简化版的撮合引擎,帮助您理解其核心机制。

max202011161630的博客 1177

matchengine-tools:与 TinEye 的 MatchEngine 服务交互的工具

匹配引擎工具 与服务交互的工具。 创建这些工具是为了支持批量生成 MatchEngine 生成的图像相似性数据。 这远不是该服务最常见的用例,而是一种适用于艺术分析的用例。 (如果您正在寻找更通用的 MatchEngine 库,我可以推荐这些工具使用的。)有关使用它的项目的更多信息,以及此特定实现可以在以下找到。 简而言之,按照 列出的细节,数据是通过两个步骤生成的。 首先:将您希望分析的所有图像批量上传到 MatchEngine 服务。 bulk-upload.js脚本提供了此功能。 第二:通过从 MatchEngine 下载所有图像相似性数据并将其存储在本地 JSON 文件中。 这就是get-similar.js提供的。 安装 这些工具使用 ,必须安装它才能正确运行。 您需要获取此存储库的副本并将其放置在本地某个位置。 在此目录中,您需要运行以下命令,以安装运行此脚本所需的所有依

Megatron单机多卡Qwen2.5:pre-train+sft

英伟达:https://github.com/NVIDIA/Megatron-LM/releases/tag/core_r0.8.0阿里:https://github.com/alibaba/Pai-Megatron-Patch/releases/tag/v0.10.2。

weixin_46873015的博客 2183

交易撮合引擎原理与实现【含源码】

交易撮合引擎原理与实现【含源码】 发表于 2019-07-22 | 分类于 区块链 区块链开发课程精选 http://blog.hubwiz.com/2019/07/22/build-a-crypto-exchange/ 交易撮合引擎(Matching/Trading Engine),顾名思义是用来撮合交易的软件,广泛地应用在 金融、证券、加密货币交易等领域。交易引擎负责管理加密资产市场中所有的开口订单(Open Orders), 并在发现匹配的订单对(Trading Pair)时自动执行交易。本文将首先介

代码过客 5200

数字IC验证秋招真题的工程逻辑拆解

数字IC验证是芯片流片前保障功能正确性的核心环节,其本质在于用有限资源穷尽失效路径。它依托UVM等验证方法学,融合协议理解(如AMBA/AXI)、架构分析(如Cache一致性)与功能建模(如UART/DMA),通过随机约束、断言嵌入、覆盖率驱动和故障注入等技术实现高置信度验证。在工业实践中,验证工程师需将抽象协议转化为可观测信号行为,将笔试‘八股’还原为真实项目中的场景拆解、调试归因与策略权衡。本文聚焦秋招高频真题,揭示协议时序、一致性机制与模块故障背后的工程思维范式,帮助应届生跨越从语法记忆到验证落地的能

weixin_29173777的博客 176

Raft in Rust (原子多播+撮合引擎)

前言 Raft作为一个分布式协同算法,这是原子多播的一个非常重要的视线。今天也得到了广泛的应用。当前情况下,我们为了更好的实现一个快速的撮合引擎,我们进一步探索原子多播在交易系统中的应用。Rust是现代编译执行语言的代表,可以达到可以比肩C语言的执行效率。所以,我们必然要考虑如何在Rust里面应用Raft协议。 已有项目 tikv/raft-rs https://github.com/tikv/raft-rshttps://github.com/tikv/raft-rsraft-rs/exampl.

weixin_41308834的博客 3313

用Arduino和FS-i6X遥控器,从零开始打造你的第一只仿生扑翼蝴蝶(附完整代码解析)

本文详细介绍了如何利用Arduino和FS-i6X遥控器从零开始制作仿生扑翼蝴蝶,包括硬件准备、电路连接、代码解析和调试技巧。通过完整的代码示例和参数说明,帮助读者快速掌握仿生机器人的制作要点,实现蝴蝶的自然飞行效果。

weixin_28727975的博客 315

window下迁移SVN仓库到新的windows服务器

window下迁移SVN仓库到新的windows服务器

Bertram的博客 4695

浅谈撮合引擎

撮合引擎简易架构

finalAmativeness的博客 3319

2025年7月5日全国青少年信息素养大赛Python编程初中组复赛真题+答案解析

2025年7月5日全国青少年信息素养大赛Python编程初中组复赛真题+答案解析

伶俐角少儿编程 469

撮合引擎是交易系统

清算的工作就是把买单冻结的USD扣掉,并加上买入所得的BTC,同时,把卖单冻结的BTC扣掉,并加上卖出所得的USD。撮合引擎本质上就是维护一个买卖盘列表,然后按价格优先原则对订单进行撮合,能够成交的就输出成交结果,不能成交的放入买卖盘。在撮合引擎输出成交记录给清算系统的同时,它还把去除用户和订单相关信息的成交记录输出给行情系统(Quotation),由行情系统保存市场的成交价、成交量等信息,并输出实时价格、K线图等技术数据,以便公开市场查询。经过这样的模块化设计,一个证券交易系统就具备了雏型。

qq_30505673的博客 1252

C# 从数秒到毫秒:MySQL+Redis百万数据优化实战全解析

在处理百万级数据时,传统单体数据库常面临查询效率低下、数据库负载过高和用户体验差等问题。为解决这些性能瓶颈,可以采用MySQL分库分表、Redis缓存和异步统计的组合策略。 数据库分片:通过水平分表和分库实现,将单表数据分散到多个物理表或数据库实例中,降低单点负载。 Redis缓存:利用Redis缓存高频数据,减少数据库查询压力,提升响应速度。 异步统计:通过消息队列(如RabbitMQ)解耦统计任务,后台处理非实时任务,避免阻塞主流程。 这些优化策略能够显著提升系统性能,确保在高并发和大数据量场景下的稳定

墨夶的博客 853

uniapp - 实现 App 端 “半屏幕“ 连续扫码功能,页面只有半个屏幕是扫码框并且可持续连续扫码获取数据(不使用官方 uni.scanCode API,因为无法连续扫码!)详细示例源码插件教程

uniapp app端实现半屏幕扫码,uniapp 扫一扫半个屏幕,uniapp 扫一扫,uniapp持续扫码实现,uniapp怎么自定义扫码和连续扫码,uni-app App端半屏连续扫码,uniapp 扫一扫半个屏幕,uniapp自定义扫码页面样式,实现连续扫码功能(uniapp),uniapp - 实现 App 端 "半屏幕" 连续扫码功能,页面只有半个屏幕是扫码框并且可持续连续扫码获取数据(不使用官方 uni.scanCode API,因为无法连续扫码!)详细示例源码插件教程。

✅ 精选推荐文章 1万+

php撮合引擎,C++ Match Engine撮合引擎 安装搭建(ubuntu)

2.安装mysql :apt -y install mysql-server3.安装redis : apt -y install redis4.安装java1.8:apt -y install openjdk-8-jdkcd zookeepr/confmv zoo_simple.cfg zoo.cfg启动:bin/zkServer.sh start连接:bin/zkCli.shcd kafkavi...

weixin_39590601的博客 389

【肝帝一周总结:全网最全最细】十万字python教程,学不会找我!教到你会为止!!内容超多,建议收藏慢慢看!

文章目录前言一定要看python入门python缩进Python注释Python 变量1. 定义理解2. 变量名命名3. 分配多个值4. 输出变量5. 全局变量 前言一定要看 python能干什么?有什么用?好处在哪?不要我讲了,这不是我在博客该讲的,言简意赅就是:通俗易懂,上手快,实用强。我会根据自己个人理解以及国外官网翻译为中文对大家进行讲解。完整源码我也会在最下面带上地址。内容过多,我不会全部演示,你完全可以复制粘贴到自己的pycharm上运行即可。 不管是国内的菜鸟教程还是我在这里的翻译,至少你跟

全栈川川 5万+

如何通过事件溯源实现百万TPS全内存撮合交易引擎

当对股票聚合根在多台机器出现的时候,就会有产生Event版本号冲突的问题,所以在Event入库的时候,只要出现唯一索引冲突,就代表了出现了更新冲突。本人并没有从事过股票交易相关系统的开发经验,只是单纯个人喜好,根据网络上相关的一些撮合业务的描述,按照自己的理解实现的一套基于事件溯源的全内存撮合引擎。每个事件都代表一个状态变化,应用程序的状态是通过这些事件的序列重建的。撮合产生的交易Event信息,是采用批量组提交的模式进行入库到数据库磁盘中的,即使断电了也可以通过磁盘中的Event恢复的最新的状态。

luxianping的专栏 1786

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

探索 Simple Match Engine:一款高效的匹配引擎

探索 Simple Match Engine:一款高效的匹配引擎 在数据驱动的世界中,快速、准确地匹配信息变得至关重要。 是一个轻量级且强大的开源项目,旨在帮助开发者构建自己的高效匹配系统。本文将深入介绍该项目的核心功能、技术特点及应用场景,帮助您理解其价值并考虑如何将其融入您的项目。 项目简介 Simple Match Engine 是由 MichaelLiao 创建的一个小型库,它使用了 BM...

gitblog_00017的博客 584

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

2025交易所开发突围:AI增强型撮合引擎与零知识证明跨链架构

随着区块链技术的不断演进和加密货币市场的日益成熟,交易所作为数字资产交易的核心平台,正面临着前所未有的挑战与机遇。在2025年这个关键的时间节点,交易所开发领域正迎来一场深刻的技术革新,其中AI增强型撮合引擎与零知识证明跨链架构成为了突围的关键。

Lovely_xwys的博客 954

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

c语言股票源码,股票撮合系统

#includeintcount;structdate{intorderid;intstockid;floatprice;intquantity;intbs;structdate*next;};typedefstructdateDATE;typedefstructdate*PDATE;structstock{intstockid;structstock*ne...

weixin_29924799的博客 1983

数据结构设计_撮合引擎开发:数据结构设计

价值超5万的撮合引擎:开篇价值超5万的撮合引擎:MVP版本交易委托账本交易委托账本(OrderBook)是整个撮合引擎里最核心也是最复杂的数据结构,每个交易对都需要维护一份交易委托账本,账本里保存着指定交易对所有待撮合的委托单。每份账本都有两个队列,一个卖单队列和一个买单队列,两个队列都需要按照价格优先、时间优先的原则进行排序。所谓价格优先、时间优先,即是说:卖单队列的委托单是按价格由低...

weixin_39950010的博客 591

撮合引擎纯内存计算带来的GC问题

本文主要是介绍交易所内存撮合...

qq_18537055的博客 766

开源证券交易撮合引擎 jOpenExchg V0.01 预览版

项目名称:Java Open Exchange Project (jOpenExchg / jopenexchg) 项目当前版本:V0.01   项目简介: 基于GPL Licence的Java的开源证券交易撮合引擎项目。目前只是0.01版本,功能尚未完备。   已实现的撮合引擎核心功能有: 1) 限价订单的撮合及订单簿组织 2) 集合竞价价格计算及集合竞价撮合 3) 基于接...

iteye_4774的博客 1059
上一篇: 如何设置 Databend 开发环境
下一篇: Databend 源码阅读系列(一): 开篇
Databend
博客等级 码龄5年 1458粉丝 363原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值