performance tests

.gitlab-ci.yml

@@ -26,19 +26,16 @@ variables:
   cache:
     paths:
       - cargohome
-    key: "build_cache--$TARGET--$CI_COMMIT_BRANCH"
+      - target/
+    key: "build_cache--$TARGET--$CI_COMMIT_BRANCH--release"
   variables:
     CARGO_PROFILE_RELEASE_LTO: "true"
     CARGO_PROFILE_RELEASE_CODEGEN_UNITS: "1"
-    CARGO_INCREMENTAL: "false" # https://matklad.github.io/2021/09/04/fast-rust-builds.html#ci-workflow
-    CARGO_HOME: $CI_PROJECT_DIR/cargohome
   before_script:
     - 'echo "Building for target $TARGET"'
-    - "mkdir -p $CARGO_HOME"
+    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
     - "rustc --version && cargo --version && rustup show" # Print version info for debugging
     - "rustup target add $TARGET"
-    # If provided, bring in caching through sccache, which uses an external S3 endpoint to store compilation results:
-    - if [ -n "${SCCACHE_BIN_URL}" ]; then curl $SCCACHE_BIN_URL --output /sccache && chmod +x /sccache && export RUSTC_WRAPPER=/sccache; fi
   script:
     - time cargo build --target $TARGET --release
     - 'cp "target/$TARGET/release/conduit" "conduit-$TARGET"'
@@ -145,12 +142,8 @@ build:debug:cargo:x86_64-unknown-linux-musl:
     DOCKER_HOST: tcp://docker:2375/
     DOCKER_TLS_CERTDIR: ""
     DOCKER_DRIVER: overlay2
-    PLATFORMS: "linux/arm/v6,linux/arm/v7,linux/arm64,linux/amd64"
+    PLATFORMS: "linux/arm/v6,linux/arm/v7,linux/arm64/v8,linux/amd64"
     DOCKER_FILE: "docker/ci-binaries-packaging.Dockerfile"
-  cache:
-    paths:
-      - docker_cache
-    key: "$CI_JOB_NAME"
   before_script:
     - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
     # Only log in to Dockerhub if the credentials are given:
@@ -163,51 +156,80 @@ build:debug:cargo:x86_64-unknown-linux-musl:
     - mkdir -p linux/ && mv ./conduit-x86_64-unknown-linux-musl linux/amd64
     - mkdir -p linux/arm/ && mv ./conduit-arm-unknown-linux-musleabihf linux/arm/v6
     - mkdir -p linux/arm/ && mv ./conduit-armv7-unknown-linux-musleabihf linux/arm/v7
-    - mv ./conduit-aarch64-unknown-linux-musl linux/arm64
+    - mkdir -p linux/arm64/ && mv ./conduit-aarch64-unknown-linux-musl linux/arm64/v8
-    - 'export CREATED=$(date -u +''%Y-%m-%dT%H:%M:%SZ'') && echo "Docker image creation date: $CREATED"'
+    # Actually create multiarch image:
-    # Build and push image:
     - >
       docker buildx build
       --pull
       --push
-      --cache-from=type=local,src=$CI_PROJECT_DIR/docker_cache
+      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
-      --cache-to=type=local,dest=$CI_PROJECT_DIR/docker_cache
-      --build-arg CREATED=$CREATED
       --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
       --build-arg "GIT_REF=$CI_COMMIT_SHORT_SHA"
       --platform "$PLATFORMS"
-      --tag "$TAG"
+      --tag "$GL_IMAGE_TAG"
-      --tag "$TAG-alpine"
+      --tag "$GL_IMAGE_TAG-commit-$CI_COMMIT_SHORT_SHA"
-      --tag "$TAG-commit-$CI_COMMIT_SHORT_SHA"
       --file "$DOCKER_FILE" .
+    # Only try to push to docker hub, if auth data for dockerhub exists:
+    - if [ -n "${DOCKER_HUB}" ]; then docker push "$DH_IMAGE_TAG"; fi
+    - if [ -n "${DOCKER_HUB}" ]; then docker push "$DH_IMAGE_TAG-commit-$CI_COMMIT_SHORT_SHA"; fi
 
-docker:next:gitlab:
+build:docker:next:
   extends: .docker-shared-settings
   rules:
     - if: '$CI_COMMIT_BRANCH == "next"'
   variables:
-    TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:next"
+    GL_IMAGE_TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:next"
+    DH_IMAGE_TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
 
-docker:next:dockerhub:
+build:docker:master:
-  extends: .docker-shared-settings
-  rules:
-    - if: '$CI_COMMIT_BRANCH == "next" && $DOCKER_HUB'
-  variables:
-    TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
-
-docker:master:gitlab:
   extends: .docker-shared-settings
   rules:
     - if: '$CI_COMMIT_BRANCH == "master"'
   variables:
-    TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:latest"
+    GL_IMAGE_TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:latest"
+    DH_IMAGE_TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"
 
-docker:master:dockerhub:
+## Build a docker image by packaging up the x86_64-unknown-linux-musl binary into an alpine image
-  extends: .docker-shared-settings
+#.docker-shared-settings:
-  rules:
+#  stage: "build docker image"
-    - if: '$CI_COMMIT_BRANCH == "master" && $DOCKER_HUB'
+#  needs: []
-  variables:
+#  interruptible: true
-    TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"
+#  image:
+#    name: "gcr.io/kaniko-project/executor:debug"
+#    entrypoint: [""]
+#  tags: ["docker"]
+#  variables:
+#    # Configure Kaniko Caching: https://cloud.google.com/build/docs/kaniko-cache
+#    KANIKO_CACHE_ARGS: "--cache=true --cache-copy-layers=true --cache-ttl=120h --cache-repo $CI_REGISTRY_IMAGE/kaniko-ci-cache"
+#  before_script:
+#    - "mkdir -p /kaniko/.docker"
+#    - 'echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"},\"$DOCKER_HUB\":{\"username\":\"$DOCKER_HUB_USER\",\"password\":\"$DOCKER_HUB_PASSWORD\"}}}" > /kaniko/.docker/config.json'
+#
+#
+#build:docker:next:
+#  extends: .docker-shared-settings
+#  needs:
+#    - "build:release:cargo:x86_64-unknown-linux-musl"
+#  script:
+#    - >
+#      /kaniko/executor
+#      $KANIKO_CACHE_ARGS
+#      --force
+#      --context $CI_PROJECT_DIR
+#      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+#      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
+#      --build-arg "GIT_REF=$CI_COMMIT_SHORT_SHA"
+#      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
+#      --destination "$CI_REGISTRY_IMAGE/conduit:next"
+#      --destination "$CI_REGISTRY_IMAGE/conduit:next-alpine"
+#      --destination "$CI_REGISTRY_IMAGE/conduit:commit-$CI_COMMIT_SHORT_SHA"
+#      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
+#      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next-alpine"
+#      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:commit-$CI_COMMIT_SHORT_SHA"
+#  rules:
+#    - if: '$CI_COMMIT_BRANCH == "next"'
+#
+#
 
 # --------------------------------------------------------------------- #
 #  Run tests                                                            #
@@ -219,21 +241,20 @@ test:cargo:
   image: "rust:latest"
   tags: ["docker"]
   variables:
-    CARGO_HOME: "$CI_PROJECT_DIR/cargohome"
+    CARGO_HOME: "cargohome"
-    CARGO_INCREMENTAL: "false" # https://matklad.github.io/2021/09/04/fast-rust-builds.html#ci-workflow
   cache:
     paths:
+      - target
       - cargohome
-    key: "test_cache--$CI_COMMIT_BRANCH"
+    key: test_cache
   interruptible: true
   before_script:
-    - mkdir -p $CARGO_HOME
+    - mkdir -p $CARGO_HOME && echo "using $CARGO_HOME to cache cargo deps"
     - apt-get update -yqq
-    - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config
+    - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config wget
     - rustup component add clippy rustfmt
-    - curl "https://faulty-storage.de/gitlab-report" --output ./gitlab-report && chmod +x ./gitlab-report
+    - wget "https://faulty-storage.de/gitlab-report"
-    # If provided, bring in caching through sccache, which uses an external S3 endpoint to store compilation results:
+    - chmod +x ./gitlab-report
-    - if [ -n "${SCCACHE_BIN_URL}" ]; then curl $SCCACHE_BIN_URL --output /sccache && chmod +x /sccache && export RUSTC_WRAPPER=/sccache; fi
   script:
     - rustc --version && cargo --version # Print version info for debugging
     - cargo fmt --all -- --check

DEPLOY.md

@@ -12,17 +12,20 @@ only offer Linux binaries.
 
 You may simply download the binary that fits your machine. Run `uname -m` to see what you need. Now copy the right url:
 
-| CPU Architecture                            | Download stable version        |
+| CPU Architecture                            | Download link           |
-| ------------------------------------------- | ------------------------------ |
+| ------------------------------------------- | ----------------------- |
-| x84_64 / amd64 (Most servers and computers) | [Download][x84_64-musl-master] |
+| x84_64 / amd64 (Most servers and computers) | [Download][x84_64-musl] |
-| armv6                                       | [Download][armv6-musl-master]  |
+| armv6                                       | [Download][armv6-musl]  |
-| armv7 (e.g. Raspberry Pi by default)        | [Download][armv7-musl-master]  |
+| armv7 (e.g. Raspberry Pi by default)        | [Download][armv7-musl]  |
-| armv8 / aarch64                             | [Download][armv8-musl-master]  |
+| armv8 / aarch64                             | [Download][armv8-musl]  |
 
-[x84_64-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-musl?job=build:release:cargo:x86_64-unknown-linux-musl
+[x84_64-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-musl?job=build:release:cargo:x86_64-unknown-linux-musl
-[armv6-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-arm-unknown-linux-musleabihf?job=build:release:cargo:arm-unknown-linux-musleabihf
+
-[armv7-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-musleabihf?job=build:release:cargo:armv7-unknown-linux-musleabihf
+[armv6-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-arm-unknown-linux-musleabihf?job=build:release:cargo:arm-unknown-linux-musleabihf
-[armv8-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-musl?job=build:release:cargo:aarch64-unknown-linux-musl
+
+[armv7-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-musleabihf?job=build:release:cargo:armv7-unknown-linux-musleabihf
+
+[armv8-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-musl?job=build:release:cargo:aarch64-unknown-linux-musl
 
 ```bash
 $ sudo wget -O /usr/local/bin/matrix-conduit <url>

Dockerfile

@@ -54,11 +54,11 @@ RUN apk add --no-cache \
 RUN mkdir -p /srv/conduit/.local/share/conduit
 
 # Test if Conduit is still alive, uses the same endpoint as Element
-COPY ./docker/healthcheck.sh /srv/conduit/healthcheck.sh
+COPY ./docker/healthcheck.sh /srv/conduit/
 HEALTHCHECK --start-period=5s --interval=5s CMD ./healthcheck.sh
 
 # Copy over the actual Conduit binary from the builder stage
-COPY --from=builder /usr/src/conduit/target/release/conduit /srv/conduit/conduit
+COPY --from=builder /usr/src/conduit/target/release/conduit /srv/conduit/
 
 # Improve security: Don't run stuff as root, that does not need to run as root:
 # Add www-data user and group with UID 82, as used by alpine

docker/ci-binaries-packaging.Dockerfile

@@ -47,7 +47,7 @@ LABEL org.opencontainers.image.created=${CREATED} \
 RUN mkdir -p /srv/conduit/.local/share/conduit
 
 # Test if Conduit is still alive, uses the same endpoint as Element
-COPY ./docker/healthcheck.sh /srv/conduit/healthcheck.sh
+COPY ./docker/healthcheck.sh /srv/conduit/
 HEALTHCHECK --start-period=5s --interval=5s CMD ./healthcheck.sh
 
 

src/database.rs

@@ -314,11 +314,11 @@ impl Database {
                         .try_into()
                         .expect("pdu cache capacity fits into usize"),
                 )),
-                auth_chain_cache: Mutex::new(LruCache::new(1_000_000)),
+                auth_chain_cache: Mutex::new(LruCache::new(10_000_000)),
-                shorteventid_cache: Mutex::new(LruCache::new(1_000_000)),
+                shorteventid_cache: Mutex::new(LruCache::new(10_000_000)),
-                eventidshort_cache: Mutex::new(LruCache::new(1_000_000)),
+                eventidshort_cache: Mutex::new(LruCache::new(10_000_000)),
-                shortstatekey_cache: Mutex::new(LruCache::new(1_000_000)),
+                shortstatekey_cache: Mutex::new(LruCache::new(10_000_000)),
-                statekeyshort_cache: Mutex::new(LruCache::new(1_000_000)),
+                statekeyshort_cache: Mutex::new(LruCache::new(10_000_000)),
                 our_real_users_cache: RwLock::new(HashMap::new()),
                 appservice_in_room_cache: RwLock::new(HashMap::new()),
                 stateinfo_cache: Mutex::new(LruCache::new(1000)),

src/database/abstraction/sqlite.rs

@@ -21,7 +21,7 @@ thread_local! {
 
 struct PreparedStatementIterator<'a> {
     pub iterator: Box<dyn Iterator<Item = TupleOfBytes> + 'a>,
-    pub statement_ref: NonAliasingBox<rusqlite::Statement<'a>>,
+    pub statement_ref: NonAliasingBox<rusqlite::CachedStatement<'a>>,
 }
 
 impl Iterator for PreparedStatementIterator<'_> {
@@ -52,7 +52,7 @@ impl Engine {
     fn prepare_conn(path: &Path, cache_size_kb: u32) -> Result<Connection> {
         let conn = Connection::open(&path)?;
 
-        conn.pragma_update(Some(Main), "page_size", &2048)?;
+        conn.pragma_update(Some(Main), "page_size", &32768)?;
         conn.pragma_update(Some(Main), "journal_mode", &"WAL")?;
         conn.pragma_update(Some(Main), "synchronous", &"NORMAL")?;
         conn.pragma_update(Some(Main), "cache_size", &(-i64::from(cache_size_kb)))?;
@@ -136,7 +136,7 @@ impl SqliteTable {
     fn get_with_guard(&self, guard: &Connection, key: &[u8]) -> Result<Option<Vec<u8>>> {
         //dbg!(&self.name);
         Ok(guard
-            .prepare(format!("SELECT value FROM {} WHERE key = ?", self.name).as_str())?
+            .prepare_cached(format!("SELECT value FROM {} WHERE key = ?", self.name).as_str())?
             .query_row([key], |row| row.get(0))
             .optional()?)
     }
@@ -161,7 +161,7 @@ impl SqliteTable {
     ) -> Box<dyn Iterator<Item = TupleOfBytes> + 'a> {
         let statement = Box::leak(Box::new(
             guard
-                .prepare(&format!(
+                .prepare_cached(&format!(
                     "SELECT key, value FROM {} ORDER BY key ASC",
                     &self.name
                 ))
@@ -290,7 +290,7 @@ impl Tree for SqliteTable {
         if backwards {
             let statement = Box::leak(Box::new(
                 guard
-                    .prepare(&format!(
+                    .prepare_cached(&format!(
                         "SELECT key, value FROM {} WHERE key <= ? ORDER BY key DESC",
                         &self.name
                     ))
@@ -315,7 +315,7 @@ impl Tree for SqliteTable {
         } else {
             let statement = Box::leak(Box::new(
                 guard
-                    .prepare(&format!(
+                    .prepare_cached(&format!(
                         "SELECT key, value FROM {} WHERE key >= ? ORDER BY key ASC",
                         &self.name
                     ))

src/server_server.rs

@@ -47,7 +47,6 @@ use ruma::{
         },
         AnyEphemeralRoomEvent, EventType,
     },
-    int,
     receipt::ReceiptType,
     serde::JsonObject,
     signatures::{CanonicalJsonObject, CanonicalJsonValue},
@@ -751,14 +750,14 @@ pub async fn send_transaction_message_route(
                 .roomid_mutex_federation
                 .write()
                 .unwrap()
-                .entry(room_id.clone())
+                .entry(RoomId::try_from("!asdf:asfd.asdf").unwrap())
                 .or_default(),
         );
         let mutex_lock = mutex.lock().await;
         let start_time = Instant::now();
         resolved_map.insert(
             event_id.clone(),
-            handle_incoming_pdu(
+            dbg!(handle_incoming_pdu(
                 &body.origin,
                 &event_id,
                 &room_id,
@@ -767,7 +766,7 @@ pub async fn send_transaction_message_route(
                 &db,
                 &pub_key_map,
             )
-            .await
+            .await)
             .map(|_| ()),
         );
         drop(mutex_lock);
@@ -956,6 +955,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
     db: &'a Database,
     pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, String>>>,
 ) -> Result<Option<Vec<u8>>, String> {
+    warn!("Handling incoming pdu: {:?}", value);
     match db.rooms.exists(room_id) {
         Ok(true) => {}
         _ => {
@@ -1000,6 +1000,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
         return Ok(None);
     }
 
+    /* stop fetching prev events for now
     // 9. Fetch any missing prev events doing all checks listed here starting at 1. These are timeline events
     let mut graph = HashMap::new();
     let mut eventid_info = HashMap::new();
@@ -1114,6 +1115,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
             );
         }
     }
+    */
 
     upgrade_outlier_to_timeline_pdu(
         incoming_pdu,
@@ -2838,7 +2840,7 @@ async fn create_join_event(
             .roomid_mutex_federation
             .write()
             .unwrap()
-            .entry(room_id.clone())
+            .entry(RoomId::try_from("!asdf:asfd.asdf").unwrap()) // make all rooms share the same lock for now
             .or_default(),
     );
     let mutex_lock = mutex.lock().await;