├── .clang-format
├── .dockerignore
├── .github
    └── workflows
    │   ├── build-and-test.yml
    │   └── docker-image.yml
├── .gitignore
├── .vscode
    └── cmake-variants.json
├── CMakeLists.txt
├── Dockerfile
├── LICENSE
├── README.md
├── VERSION
├── Vagrantfile
├── common
    ├── CMakeLists.txt
    ├── configuration.cpp
    ├── configuration.h
    ├── constants.h
    ├── csv_writer.cpp
    ├── csv_writer.h
    ├── json_utils.h
    ├── metrics.cpp
    ├── metrics.h
    ├── offline_data_reader.cpp
    ├── offline_data_reader.h
    ├── proto_utils.cpp
    ├── proto_utils.h
    ├── sharder.cpp
    ├── sharder.h
    ├── spin_latch.h
    ├── string_utils.cpp
    ├── string_utils.h
    ├── thread_utils.h
    └── types.h
├── connection
    ├── CMakeLists.txt
    ├── broker.cpp
    ├── broker.h
    ├── poller.cpp
    ├── poller.h
    ├── sender.cpp
    ├── sender.h
    └── zmq_utils.h
├── data_structure
    ├── CMakeLists.txt
    ├── async_log.h
    ├── batch_log.cpp
    ├── batch_log.h
    ├── concurrent_hash_map.h
    └── rwlatch.h
├── examples
    ├── cluster.conf
    ├── copy.json
    ├── read.json
    ├── single.conf
    ├── sleep.json
    └── write.json
├── execution
    ├── CMakeLists.txt
    ├── execution.cpp
    ├── execution.h
    ├── key_value.cpp
    ├── tpcc.cpp
    └── tpcc
    │   ├── constants.h
    │   ├── deliver.cpp
    │   ├── load_tables.cpp
    │   ├── load_tables.h
    │   ├── metadata_initializer.cpp
    │   ├── metadata_initializer.h
    │   ├── new_order.cpp
    │   ├── order_status.cpp
    │   ├── payment.cpp
    │   ├── scalar.h
    │   ├── stock_level.cpp
    │   ├── storage_adapter.cpp
    │   ├── storage_adapter.h
    │   ├── table.h
    │   ├── transaction.h
    │   └── types.h
├── install-deps.sh
├── module
    ├── CMakeLists.txt
    ├── base
    │   ├── module.cpp
    │   ├── module.h
    │   ├── networked_module.cpp
    │   └── networked_module.h
    ├── consensus.cpp
    ├── consensus.h
    ├── forwarder.cpp
    ├── forwarder.h
    ├── interleaver.cpp
    ├── interleaver.h
    ├── multi_home_orderer.cpp
    ├── multi_home_orderer.h
    ├── scheduler.cpp
    ├── scheduler.h
    ├── scheduler_components
    │   ├── ddr_lock_manager.cpp
    │   ├── ddr_lock_manager.h
    │   ├── old_lock_manager.cpp
    │   ├── old_lock_manager.h
    │   ├── per_key_remaster_manager.cpp
    │   ├── per_key_remaster_manager.h
    │   ├── remaster_manager.h
    │   ├── rma_lock_manager.cpp
    │   ├── rma_lock_manager.h
    │   ├── simple_remaster_manager.cpp
    │   ├── simple_remaster_manager.h
    │   ├── txn_holder.cpp
    │   ├── txn_holder.h
    │   ├── worker.cpp
    │   └── worker.h
    ├── sequencer.cpp
    ├── sequencer.h
    ├── server.cpp
    ├── server.h
    ├── txn_generator.cpp
    └── txn_generator.h
├── paxos
    ├── CMakeLists.txt
    ├── acceptor.cpp
    ├── acceptor.h
    ├── leader.cpp
    ├── leader.h
    ├── simulated_multi_paxos.cpp
    └── simulated_multi_paxos.h
├── proto
    ├── api.proto
    ├── configuration.proto
    ├── internal.proto
    ├── modules.proto
    ├── offline_data.proto
    └── transaction.proto
├── service
    ├── benchmark.cpp
    ├── client.cpp
    ├── scheduler_benchmark.cpp
    ├── service_utils.h
    └── slog.cpp
├── storage
    ├── CMakeLists.txt
    ├── lookup_master_index.h
    ├── mem_only_storage.h
    ├── metadata_initializer.cpp
    ├── metadata_initializer.h
    └── storage.h
├── test
    ├── CMakeLists.txt
    ├── common
    │   └── string_utils_test.cpp
    ├── connection
    │   ├── broker_and_sender_test.cpp
    │   └── zmq_utils_test.cpp
    ├── data_structure
    │   ├── batch_log_test.cpp
    │   └── concurrent_hash_map_test.cpp
    ├── e2e
    │   └── e2e_test.cpp
    ├── execution
    │   └── tpcc
    │   │   ├── table_test.cpp
    │   │   └── transaction_test.cpp
    ├── module
    │   ├── forwarder_test.cpp
    │   ├── interleaver_test.cpp
    │   ├── scheduler_components
    │   │   ├── ddr_lock_manager_test.cpp
    │   │   ├── old_lock_manager_test.cpp
    │   │   ├── per_key_remaster_manager_test.cpp
    │   │   ├── rma_lock_manager_test.cpp
    │   │   └── simple_remaster_manager_test.cpp
    │   ├── scheduler_test.cpp
    │   └── sequencer_test.cpp
    ├── paxos
    │   └── paxos_test.cpp
    ├── storage
    │   └── mem_only_storage_test.cpp
    ├── test_utils.cpp
    └── test_utils.h
├── tools
    ├── admin.py
    ├── aws.py
    ├── aws
    │   └── spot_cluster_config_template.json
    ├── common.py
    ├── deinterleave.py
    ├── fnv_hash.py
    ├── gen_data.py
    ├── microbenchmark.sh
    ├── netem.py
    ├── proto
    │   ├── configuration_pb2.py
    │   ├── modules_pb2.py
    │   ├── offline_data_pb2.py
    │   └── transaction_pb2.py
    └── requirements.txt
├── version.h.in
└── workload
    ├── CMakeLists.txt
    ├── basic.cpp
    ├── basic.h
    ├── cockroach.cpp
    ├── cockroach.h
    ├── remastering.cpp
    ├── remastering.h
    ├── tpcc.cpp
    ├── tpcc.h
    └── workload.h


/.dockerignore:
--------------------------------------------------------------------------------
 1 | Dockerfile
 2 | build
 3 | .vscode
 4 | .deps
 5 | .dockerignore
 6 | *.dat
 7 | venv
 8 | tmp
 9 | config
10 | README.md


--------------------------------------------------------------------------------
/.github/workflows/build-and-test.yml:
--------------------------------------------------------------------------------
 1 | name: Build and Test
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | env:
 6 |   BUILD_TYPE: Debug
 7 |   GLOG_v: 4
 8 |   GLOG_logtostderr: 1
 9 | 
10 | jobs:
11 |   build-and-test:
12 |     runs-on: ubuntu-latest
13 |     strategy:
14 |       # Allow other jobs to continue when one job fails
15 |       fail-fast: false
16 |       matrix:
17 |         remaster: [none, simple, per_key, counterless]
18 |         lock: [old, rma, ddr]
19 |         exclude:
20 |           - remaster: simple
21 |             lock: rma
22 |           - remaster: simple
23 |             lock: ddr
24 |           - remaster: per_key
25 |             lock: rma
26 |           - remaster: per_key
27 |             lock: ddr
28 |           - remaster: counterless
29 |             lock: old
30 | 
31 |     steps:
32 |     - name: Get latest CMake
33 |       uses: lukka/get-cmake@latest
34 | 
35 |     - uses: actions/checkout@v2
36 | 
37 |     - name: Cache dependencies
38 |       uses: actions/cache@v2
39 |       with:
40 |         path: .deps
41 |         key: ${{ runner.os }}-build-${{ hashFiles('**/CMakeFiles.txt') }}
42 |         restore-keys: |
43 |           ${{ runner.os }}-build-
44 |           ${{ runner.os }}-
45 | 
46 |     - name: Install dependencies
47 |       run: ./install-deps.sh
48 | 
49 |     - name: Create Build Environment
50 |       run: cmake -E make_directory ${{ github.workspace }}/build
51 | 
52 |     - name: Configure CMake
53 |       shell: bash
54 |       env:
55 |         REMASTER_PROTOCOL: ${{ matrix.remaster }}
56 |         LOCK_MANAGER: ${{ matrix.lock }}
57 |       working-directory: ${{ github.workspace }}/build
58 |       run: cmake -S $GITHUB_WORKSPACE -B . 
59 |         -DCMAKE_BUILD_TYPE=$BUILD_TYPE 
60 |         -DBUILD_SLOG_CLIENT=OFF 
61 |         -DBUILD_SLOG_TESTS=ON
62 |         -DREMASTER_PROTOCOL=$REMASTER_PROTOCOL
63 |         -DLOCK_MANAGER=$LOCK_MANAGER
64 | 
65 |     - name: Build
66 |       working-directory: ${{ github.workspace }}/build
67 |       shell: bash
68 |       run: cmake --build . --config $BUILD_TYPE --parallel 4
69 | 
70 |     - name: Test
71 |       working-directory: ${{ github.workspace }}/build
72 |       shell: bash
73 |       run: ctest -C $BUILD_TYPE --output-on-failure
74 | 


--------------------------------------------------------------------------------
/.github/workflows/docker-image.yml:
--------------------------------------------------------------------------------
 1 | name: Create Docker Image
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 |       - dev
 8 | 
 9 | jobs:
10 |   build-image:
11 |     runs-on: ubuntu-latest
12 |     strategy:
13 |       matrix:
14 |         include:
15 |           - remaster: counterless
16 |             lock: rma
17 |           - remaster: counterless
18 |             lock: ddr
19 | 
20 |     steps:
21 |     - uses: actions/checkout@v2
22 | 
23 |     - name: Cache Docker layers
24 |       uses: actions/cache@v2
25 |       with:
26 |         path: /tmp/.buildx-cache
27 |         key: ${{ runner.os }}-buildx-${{ github.sha }}
28 |         restore-keys: |
29 |           ${{ runner.os }}-buildx-
30 | 
31 |     - name: Login to Docker Hub
32 |       uses: docker/login-action@v1
33 |       with:
34 |         username: ${{ secrets.DOCKER_HUB_USERNAME }}
35 |         password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
36 | 
37 |     - name: Set up Docker Buildx
38 |       id: buildx
39 |       uses: docker/setup-buildx-action@v1
40 |     
41 |     - name: Compute tag
42 |       env:
43 |         LOCK: ${{ matrix.lock }}
44 |       id: compute_tag
45 |       run: |
46 |         echo "::set-output name=sha::${LOCK}-${GITHUB_SHA:0:7}"
47 |         echo "::set-output name=branch::${LOCK}-${GITHUB_REF##refs/heads/}"
48 | 
49 |     - name: Build and push
50 |       id: docker_build
51 |       uses: docker/build-push-action@v2
52 |       with:
53 |         push: true
54 |         tags: ctring/slog:${{ steps.compute_tag.outputs.sha }},ctring/slog:${{ steps.compute_tag.outputs.branch }}
55 |         builder: ${{ steps.buildx.outputs.name }}
56 |         cache-from: type=local,src=/tmp/.buildx-cache
57 |         cache-to: type=local,dest=/tmp/.buildx-cache
58 |         build-args: |
59 |           CMAKE_OPTIONS=-DLOCK_MANAGER=${{ matrix.lock }} -DREMASTER_PROTOCOL=${{ matrix.remaster }}
60 | 
61 |     - name: Image digest
62 |       run: echo ${{ steps.docker_build.outputs.digest }}


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # VS Code
 2 | .vscode
 3 | !.vscode/cmake-variants.json
 4 | 
 5 | # Prerequisites
 6 | *.d
 7 | 
 8 | # Compiled Object files
 9 | *.slo
10 | *.lo
11 | *.o
12 | *.obj
13 | 
14 | # Precompiled Headers
15 | *.gch
16 | *.pch
17 | 
18 | # Compiled Dynamic libraries
19 | *.so
20 | *.dylib
21 | *.dll
22 | 
23 | # Fortran module files
24 | *.mod
25 | *.smod
26 | 
27 | # Compiled Static libraries
28 | *.lai
29 | *.la
30 | *.a
31 | *.lib
32 | 
33 | # Executables
34 | *.exe
35 | *.out
36 | *.app
37 | 
38 | # Build and dependencies folders
39 | build/
40 | .deps/
41 | .dep/
42 | 
43 | # Byte-compiled / optimized / DLL files
44 | __pycache__/
45 | *.py[cod]
46 | *$py.class
47 | 
48 | # Installer logs
49 | pip-log.txt
50 | pip-delete-this-directory.txt
51 | 
52 | # Jupyter Notebook
53 | .ipynb_checkpoints
54 | 
55 | # Environments
56 | .env
57 | .venv
58 | env/
59 | venv/
60 | ENV/
61 | env.bak/
62 | venv.bak/
63 | 
64 | # Data files
65 | *.dat


--------------------------------------------------------------------------------
/.vscode/cmake-variants.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "buildType": {
 3 |     "default": "debug",
 4 |     "choices": {
 5 |       "asan": {
 6 |         "short": "Asan",
 7 |         "long": "Address sanitizer",
 8 |         "buildType": "Asan"
 9 |       },
10 |       "tsan": {
11 |         "short": "Tsan",
12 |         "long": "Thread sanitizer",
13 |         "buildType": "Tsan"
14 |       },
15 |       "ubsan": {
16 |         "short": "Ubsan",
17 |         "long": "Undefined behaviour sanitizer",
18 |         "buildType": "Ubsan"
19 |       },
20 |       "debug": {
21 |         "short": "Debug",
22 |         "long": "Emit debug information",
23 |         "buildType": "Debug"
24 |       },
25 |       "relwithdebinfo": {
26 |         "short": "RelWithDebInfo",
27 |         "long": "Optimize generated code with debug info",
28 |         "buildType": "RelWithDebInfo"
29 |       },
30 |       "release": {
31 |         "short": "Release",
32 |         "long": "Optimize generated code",
33 |         "buildType": "Release"
34 |       }
35 |     }
36 |   },
37 |   "remasterProtocol": {
38 |     "default": "none-rma",
39 |     "choices": {
40 |       "none-old": {
41 |         "short": "None/OLD",
42 |         "long": "No remaster protocol with OLD lock manager",
43 |         "settings": {
44 |           "REMASTER_PROTOCOL": "NONE",
45 |           "LOCK_MANAGER": "OLD"
46 |         }
47 |       },
48 |       "none-rma": {
49 |         "short": "None/RMA",
50 |         "long": "No remaster protocol with RMA lock manager",
51 |         "settings": {
52 |           "REMASTER_PROTOCOL": "NONE",
53 |           "LOCK_MANAGER": "RMA"
54 |         }
55 |       },
56 |       "none-ddr": {
57 |         "short": "None/DDR",
58 |         "long": "No remaster protocol with DDR lock manager",
59 |         "settings": {
60 |           "REMASTER_PROTOCOL": "NONE",
61 |           "LOCK_MANAGER": "DDR"
62 |         }
63 |       },
64 |       "simple": {
65 |         "short": "Simple",
66 |         "long": "Simple remaster protocol",
67 |         "settings": {
68 |           "REMASTER_PROTOCOL": "SIMPLE",
69 |           "LOCK_MANAGER": "OLD"
70 |         }
71 |       },
72 |       "perkey": {
73 |         "short": "PerKey",
74 |         "long": "Per-key remaster protocol",
75 |         "settings": {
76 |           "REMASTER_PROTOCOL": "PER_KEY",
77 |           "LOCK_MANAGER": "OLD"
78 |         }
79 |       },
80 |       "counterless-rma": {
81 |         "short": "Counterless/RMA",
82 |         "long": "Counterless remaster protocol with RMA lock manager",
83 |         "settings": {
84 |           "REMASTER_PROTOCOL": "COUNTERLESS",
85 |           "LOCK_MANAGER": "RMA"
86 |         }
87 |       },
88 |       "counterless-ddr": {
89 |         "short": "Counterless/DDR",
90 |         "long": "Counterless remaster protocol with DDR lock manager",
91 |         "settings": {
92 |           "REMASTER_PROTOCOL": "COUNTERLESS",
93 |           "LOCK_MANAGER": "DDR"
94 |         }
95 |       }
96 |     }
97 |   }
98 | }


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM ubuntu:focal AS builder
 2 |     ARG CMAKE_OPTIONS
 3 | 
 4 |     # Avoid interactive installation
 5 |     ENV DEBIAN_FRONTEND=noninteractive 
 6 |     RUN apt-get update
 7 |     RUN apt-get -y install wget build-essential cmake git pkg-config
 8 | 
 9 |     WORKDIR /src
10 | 
11 |     COPY ./install-deps.sh .
12 |     RUN ./install-deps.sh -d
13 | 
14 |     COPY . .
15 |     RUN rm -rf build \
16 |         && mkdir build \
17 |         && cd build \
18 |         && cmake .. -DBUILD_SLOG_TESTS=OFF ${CMAKE_OPTIONS} -DCMAKE_BUILD_TYPE=release \
19 |         && make -j$(nproc) \
20 |         && cd ..
21 | 
22 | FROM ubuntu:focal AS runner
23 |     # If set (to anything), also create an image with tools (exclude the toolings)
24 |     ARG INCLUDE_TOOLS
25 | 
26 |     WORKDIR /opt/slog
27 |     COPY --from=builder /src/build/slog .
28 |     COPY --from=builder /src/build/client .
29 |     COPY --from=builder /src/build/benchmark .
30 |     COPY --from=builder /src/build/scheduler_benchmark .
31 |     COPY --from=builder /src/examples/*.conf ./
32 |     COPY --from=builder /src/tools/ tools/
33 | 
34 |     RUN if [ -n "$INCLUDE_TOOLS" ]; then \
35 |         apt-get update; \
36 |         apt-get -y install python3 python3-pip; \
37 |         python3 -m pip install -r tools/requirements.txt; \
38 |         chmod +x tools/*.py; \
39 |         fi
40 | 
41 |     ENV PATH="/opt/slog:${PATH}"
42 |     ENV PATH="/opt/slog/tools:${PATH}"


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Cuong Nguyen
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/VERSION:
--------------------------------------------------------------------------------
1 | 1.0.735
2 | 


--------------------------------------------------------------------------------
/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # -*- mode: ruby -*-
 2 | # vi: set ft=ruby :
 3 | 
 4 | # All Vagrant configuration is done below. The "2" in Vagrant.configure
 5 | # configures the configuration version (we support older styles for
 6 | # backwards compatibility). Please don't change it unless you know what
 7 | # you're doing.
 8 | Vagrant.configure("2") do |config|
 9 |   # The most common configuration options are documented and commented below.
10 |   # For a complete reference, please see the online documentation at
11 |   # https://docs.vagrantup.com.
12 | 
13 |   # Every Vagrant development environment requires a box. You can search for
14 |   # boxes at https://vagrantcloud.com/search.
15 |   config.vm.box = "ubuntu/eoan64"
16 | 
17 |   # Note: requires vagrant-disksize plugin
18 |   config.disksize.size = '20GB'
19 | 
20 |   # Disable automatic box update checking. If you disable this, then
21 |   # boxes will only be checked for updates when the user runs
22 |   # `vagrant box outdated`. This is not recommended.
23 |   # config.vm.box_check_update = false
24 | 
25 |   # Create a forwarded port mapping which allows access to a specific port
26 |   # within the machine from a port on the host machine. In the example below,
27 |   # accessing "localhost:8080" will access port 80 on the guest machine.
28 |   # NOTE: This will enable public access to the opened port
29 |   # config.vm.network "forwarded_port", guest: 80, host: 8080
30 | 
31 |   # Create a forwarded port mapping which allows access to a specific port
32 |   # within the machine from a port on the host machine and only allow access
33 |   # via 127.0.0.1 to disable public access
34 |   # config.vm.network "forwarded_port", guest: 80, host: 8080, host_ip: "127.0.0.1"
35 | 
36 |   # Create a private network, which allows host-only access to the machine
37 |   # using a specific IP.
38 |   # config.vm.network "private_network", ip: "192.168.33.10"
39 | 
40 |   # Create a public network, which generally matched to bridged network.
41 |   # Bridged networks make the machine appear as another physical device on
42 |   # your network.
43 |   # config.vm.network "public_network"
44 | 
45 |   # Share an additional folder to the guest VM. The first argument is
46 |   # the path on the host to the actual folder. The second argument is
47 |   # the path on the guest to mount the folder. And the optional third
48 |   # argument is a set of non-required options.
49 |   # config.vm.synced_folder "../data", "/vagrant_data"
50 | 
51 |   # Provider-specific configuration so you can fine-tune various
52 |   # backing providers for Vagrant. These expose provider-specific options.
53 |   # Example for VirtualBox:
54 |   #
55 |   config.vm.provider "virtualbox" do |vb|
56 |     # Display the VirtualBox GUI when booting the machine
57 |     # vb.gui = true
58 |   
59 |     # Customize the amount of memory on the VM:
60 |     vb.memory = "4096"
61 | 
62 |     # box was timing out on startup. from https://bugs.launchpad.net/cloud-images/+bug/1829625
63 |     vb.customize ["modifyvm", :id, "--uart1", "0x3F8", "4"]
64 |     vb.customize ["modifyvm", :id, "--uartmode1", "file", "./ttyS0.log"]
65 |   end
66 |   #
67 |   # View the documentation for the provider you are using for more
68 |   # information on available options.
69 | 
70 |   # Enable provisioning with a shell script. Additional provisioners such as
71 |   # Puppet, Chef, Ansible, Salt, and Docker are also available. Please see the
72 |   # documentation for more information about their specific syntax and use.
73 |   # config.vm.provision "shell", inline: <<-SHELL
74 |   #   apt-get update
75 |   #   apt-get install -y apache2
76 |   # SHELL
77 | end
78 | 


--------------------------------------------------------------------------------
/common/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | target_sources(slog-core
 2 |   PRIVATE
 3 |     configuration.cpp
 4 |     configuration.h
 5 |     constants.h
 6 |     csv_writer.cpp
 7 |     csv_writer.h
 8 |     json_utils.h
 9 |     metrics.cpp
10 |     metrics.h
11 |     offline_data_reader.cpp
12 |     offline_data_reader.h
13 |     proto_utils.cpp
14 |     proto_utils.h
15 |     sharder.cpp
16 |     sharder.h
17 |     spin_latch.h
18 |     string_utils.cpp
19 |     string_utils.h
20 |     thread_utils.h
21 |     types.h)


--------------------------------------------------------------------------------
/common/configuration.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <chrono>
 4 | #include <string>
 5 | #include <vector>
 6 | 
 7 | #include "common/types.h"
 8 | #include "proto/configuration.pb.h"
 9 | #include "proto/internal.pb.h"
10 | 
11 | namespace slog {
12 | 
13 | class Configuration;
14 | 
15 | using ConfigurationPtr = std::shared_ptr<const Configuration>;
16 | 
17 | class Configuration {
18 |  public:
19 |   static ConfigurationPtr FromFile(const std::string& file_path, const std::string& local_address = "");
20 | 
21 |   Configuration(const internal::Configuration& config, const std::string& local_address);
22 | 
23 |   const internal::Configuration& proto_config() const;
24 |   const std::string& protocol() const;
25 |   const std::vector<std::string>& all_addresses() const;
26 |   const std::string& address(uint32_t replica, uint32_t partition) const;
27 |   const std::string& address(MachineId machine_id) const;
28 |   uint32_t broker_ports(int i) const;
29 |   uint32_t broker_ports_size() const;
30 |   uint32_t server_port() const;
31 |   uint32_t forwarder_port() const;
32 |   uint32_t sequencer_port() const;
33 |   uint32_t num_replicas() const;
34 |   uint32_t num_partitions() const;
35 |   uint32_t num_workers() const;
36 |   std::vector<MachineId> all_machine_ids() const;
37 |   std::chrono::milliseconds mh_orderer_batch_duration() const;
38 |   std::chrono::milliseconds forwarder_batch_duration() const;
39 |   std::chrono::milliseconds sequencer_batch_duration() const;
40 |   int sequencer_batch_size() const;
41 |   bool sequencer_rrr() const;
42 |   uint32_t replication_factor() const;
43 | 
44 |   const std::string& local_address() const;
45 |   uint32_t local_replica() const;
46 |   uint32_t local_partition() const;
47 |   MachineId local_machine_id() const;
48 |   MachineId MakeMachineId(uint32_t replica, uint32_t partition) const;
49 |   std::pair<uint32_t, uint32_t> UnpackMachineId(MachineId machine_id) const;
50 | 
51 |   uint32_t leader_replica_for_multi_home_ordering() const;
52 |   uint32_t leader_partition_for_multi_home_ordering() const;
53 | 
54 |   uint32_t replication_delay_pct() const;
55 |   uint32_t replication_delay_amount_ms() const;
56 | 
57 |   std::vector<TransactionEvent> enabled_events() const;
58 |   bool bypass_mh_orderer() const;
59 |   std::vector<int> cpu_pinnings(ModuleId module) const;
60 |   bool return_dummy_txn() const;
61 |   int recv_retries() const;
62 |   internal::ExecutionType execution_type() const;
63 |   const std::vector<uint32_t> replication_order() const;
64 |   bool synchronized_batching() const;
65 |   uint32_t sample_rate() const;
66 |   std::vector<int> distance_ranking_from(int replica_id) const;
67 | 
68 |   int broker_rcvbuf() const;
69 |   int long_sender_sndbuf() const;
70 | 
71 |  private:
72 |   internal::Configuration config_;
73 |   std::string local_address_;
74 |   int local_replica_;
75 |   int local_partition_;
76 | 
77 |   std::vector<std::string> all_addresses_;
78 |   std::vector<uint32_t> replication_order_;
79 | };
80 | 
81 | }  // namespace slog


--------------------------------------------------------------------------------
/common/constants.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <chrono>
 4 | #include <string>
 5 | 
 6 | #include "common/types.h"
 7 | 
 8 | namespace slog {
 9 | 
10 | const auto kModuleTimeout = std::chrono::milliseconds(1000);
11 | 
12 | const Channel kServerChannel = 1;
13 | const Channel kForwarderChannel = 2;
14 | const Channel kSequencerChannel = 3;
15 | const Channel kMultiHomeOrdererChannel = 4;
16 | const Channel kInterleaverChannel = 5;
17 | const Channel kLocalLogChannel = 6;
18 | const Channel kSchedulerChannel = 7;
19 | const Channel kLocalPaxos = 8;
20 | const Channel kGlobalPaxos = 9;
21 | const Channel kWorkerChannel = 10;
22 | // Broker channels range from kBrokerChannel to kMaxChannel - 1
23 | const Channel kBrokerChannel = 11;
24 | const Channel kMaxChannel = 15;
25 | 
26 | const uint32_t kMaxNumMachines = 100;
27 | 
28 | const uint32_t kPaxosDefaultLeaderPosition = 0;
29 | 
30 | const size_t kLockTableSizeLimit = 1000000;
31 | 
32 | /****************************
33 |  *      Statistic Keys
34 |  ****************************/
35 | 
36 | /* Server */
37 | const char TXN_ID_COUNTER[] = "txn_id_counter";
38 | const char NUM_PENDING_RESPONSES[] = "num_pending_responses";
39 | const char NUM_PARTIALLY_FINISHED_TXNS[] = "num_partially_finished_txns";
40 | const char PENDING_RESPONSES[] = "pending_responses";
41 | const char PARTIALLY_FINISHED_TXNS[] = "partially_finished_txns";
42 | 
43 | /* Forwarder */
44 | const char FORW_BATCH_SIZE_PCTLS[] = "forw_batch_size_pctls";
45 | const char FORW_BATCH_DURATION_MS_PCTLS[] = "forw_batch_duration_ms_pctls";
46 | 
47 | /* Multi-home orderer */
48 | const char MHO_BATCH_SIZE_PCTLS[] = "mho_batch_size_pctls";
49 | const char MHO_BATCH_DURATION_MS_PCTLS[] = "mho_batch_duration_ms_pctls";
50 | 
51 | /* Sequencer */
52 | const char SEQ_BATCH_SIZE_PCTLS[] = "seq_batch_size_pctls";
53 | const char SEQ_BATCH_DURATION_MS_PCTLS[] = "seq_batch_duration_ms_pctls";
54 | 
55 | /* Scheduler */
56 | const char ALL_TXNS[] = "all_txns";
57 | const char NUM_ALL_TXNS[] = "num_all_txns";
58 | const char NUM_LOCKED_KEYS[] = "num_locked_keys";
59 | const char LOCK_MANAGER_TYPE[] = "lock_manager_type";
60 | const char NUM_TXNS_WAITING_FOR_LOCK[] = "num_txns_waiting_for_lock";
61 | const char NUM_WAITING_FOR_PER_TXN[] = "num_waiting_for_per_txn";
62 | const char LOCK_TABLE[] = "lock_table";
63 | const char WAITED_BY_GRAPH[] = "waited_by_graph";
64 | const char TXN_ID[] = "id";
65 | const char TXN_DONE[] = "done";
66 | const char TXN_ABORTING[] = "aborting";
67 | const char TXN_NUM_LO[] = "num_lo";
68 | const char TXN_NUM_DISPATCHES[] = "num_dispatches";
69 | const char TXN_EXPECTED_NUM_LO[] = "expected_num_lo";
70 | const char TXN_MULTI_HOME[] = "multi_home";
71 | const char TXN_MULTI_PARTITION[] = "multi_partition";
72 | 
73 | }  // namespace slog


--------------------------------------------------------------------------------
/common/csv_writer.cpp:
--------------------------------------------------------------------------------
 1 | #include "common/csv_writer.h"
 2 | 
 3 | #include <stdexcept>
 4 | 
 5 | namespace slog {
 6 | 
 7 | CSVWriter::CSVWriter(const std::string& file_name, const std::vector<std::string>& columns, char delimiter) {
 8 |   if (columns.empty()) {
 9 |     throw std::runtime_error("There must be at least one column");
10 |   }
11 |   num_columns_ = columns.size();
12 |   line_items_ = 0;
13 |   delim_ = delimiter;
14 | 
15 |   file_ = std::ofstream(file_name, std::ios::out);
16 |   if (!file_) {
17 |     throw std::runtime_error(std::string("Cannot open file: ") + file_name);
18 |   }
19 |   bool first = true;
20 |   for (const auto& col : columns) {
21 |     if (!first) {
22 |       file_ << ",";
23 |     }
24 |     file_ << col;
25 |     first = false;
26 |   }
27 |   file_ << "\n";
28 | }
29 | 
30 | void CSVWriter::AppendDelim() {
31 |   if (line_items_ > 1) {
32 |     file_ << delim_;
33 |   }
34 | }
35 | 
36 | void CSVWriter::IncrementLineItemsAndCheck() {
37 |   line_items_++;
38 |   if (line_items_ > num_columns_) {
39 |     throw std::runtime_error("Number of items exceeds number of columns");
40 |   }
41 | }
42 | 
43 | }  // namespace slog


--------------------------------------------------------------------------------
/common/csv_writer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <fstream>
 4 | #include <string>
 5 | #include <vector>
 6 | 
 7 | namespace slog {
 8 | 
 9 | const struct CSVWriterLineEnder {
10 | } csvendl;
11 | 
12 | class CSVWriter {
13 |  public:
14 |   CSVWriter(const std::string& file_name, const std::vector<std::string>& columns, char delimiter = ',');
15 | 
16 |   template <typename T, typename = std::enable_if_t<std::is_arithmetic<T>::value>>
17 |   CSVWriter& operator<<(T val) {
18 |     IncrementLineItemsAndCheck();
19 |     AppendDelim();
20 |     file_ << val;
21 |     return *this;
22 |   }
23 | 
24 |   CSVWriter& operator<<(const std::string& str) {
25 |     IncrementLineItemsAndCheck();
26 |     AppendDelim();
27 |     file_ << str;
28 |     return *this;
29 |   }
30 | 
31 |   CSVWriter& operator<<(const CSVWriterLineEnder& ender) {
32 |     if (line_items_ != num_columns_) {
33 |       throw std::runtime_error("Number of items must match number of columns");
34 |     }
35 |     (void)ender;  // Silent unused warning
36 |     file_ << "\n";
37 |     line_items_ = 0;
38 |     return *this;
39 |   }
40 | 
41 |  private:
42 |   void AppendDelim();
43 |   void IncrementLineItemsAndCheck();
44 | 
45 |   size_t line_items_;
46 |   size_t num_columns_;
47 |   std::ofstream file_;
48 |   char delim_;
49 | };
50 | 
51 | }  // namespace slog


--------------------------------------------------------------------------------
/common/json_utils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <functional>
 4 | 
 5 | #include "rapidjson/allocators.h"
 6 | #include "rapidjson/document.h"
 7 | #include "rapidjson/prettywriter.h"
 8 | #include "rapidjson/rapidjson.h"
 9 | #include "rapidjson/stringbuffer.h"
10 | #include "rapidjson/writer.h"
11 | 
12 | namespace slog {
13 | 
14 | template <typename Container, typename ValueFn>
15 | rapidjson::Value ToJsonArrayOfKeyValue(const Container& container, ValueFn value_fn,
16 |                                        rapidjson::Document::AllocatorType& alloc) {
17 |   rapidjson::Value json_array(rapidjson::kArrayType);
18 |   for (const auto& [key, value] : container) {
19 |     rapidjson::Value entry(rapidjson::kArrayType);
20 |     entry.PushBack(key, alloc).PushBack(rapidjson::Value(value_fn(value)), alloc);
21 |     json_array.PushBack(std::move(entry), alloc);
22 |   }
23 |   return json_array;
24 | }
25 | 
26 | template <typename Container>
27 | rapidjson::Value ToJsonArrayOfKeyValue(const Container& container, rapidjson::Document::AllocatorType& alloc) {
28 |   return ToJsonArrayOfKeyValue(
29 |       container, [](const auto& value) { return value; }, alloc);
30 | }
31 | 
32 | template <typename Container, typename Function>
33 | rapidjson::Value ToJsonArray(const Container& container, Function fn, rapidjson::Document::AllocatorType& alloc) {
34 |   rapidjson::Value json_array(rapidjson::kArrayType);
35 |   for (const auto& v : container) {
36 |     json_array.PushBack(rapidjson::Value(fn(v)), alloc);
37 |   }
38 |   return json_array;
39 | }
40 | 
41 | template <typename Container>
42 | rapidjson::Value ToJsonArray(const Container& container, rapidjson::Document::AllocatorType& alloc) {
43 |   return ToJsonArray(
44 |       container, [](const auto& value) { return value; }, alloc);
45 | }
46 | 
47 | const std::array<int, 11> kPctlLevels = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
48 | 
49 | template <typename Container>
50 | rapidjson::Value Percentiles(Container& container, rapidjson::Document::AllocatorType& alloc) {
51 |   rapidjson::Value pctls(rapidjson::kArrayType);
52 |   if (container.empty()) {
53 |     return pctls;
54 |   }
55 |   std::sort(container.begin(), container.end());
56 |   for (auto p : kPctlLevels) {
57 |     size_t i = p * (container.size() - 1) / 100;
58 |     pctls.PushBack(container[i], alloc);
59 |   }
60 |   return pctls;
61 | }
62 | 
63 | }  // namespace slog


--------------------------------------------------------------------------------
/common/metrics.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <atomic>
  4 | #include <memory>
  5 | #include <mutex>
  6 | #include <thread>
  7 | #include <unordered_map>
  8 | #include <vector>
  9 | 
 10 | #include "common/configuration.h"
 11 | #include "common/spin_latch.h"
 12 | #include "proto/transaction.pb.h"
 13 | 
 14 | namespace slog {
 15 | 
 16 | constexpr uint32_t kSampleMaskSize = 1 << 8;
 17 | using sample_mask_t = std::array<bool, kSampleMaskSize>;
 18 | 
 19 | class TransactionEventMetrics;
 20 | 
 21 | /**
 22 |  * Repository of metrics per thread
 23 |  */
 24 | class MetricsRepository {
 25 |  public:
 26 |   MetricsRepository(const ConfigurationPtr& config, const sample_mask_t& sample_mask);
 27 | 
 28 |   std::chrono::system_clock::time_point RecordTxnEvent(TransactionEvent event);
 29 |   std::unique_ptr<TransactionEventMetrics> Reset();
 30 | 
 31 |  private:
 32 |   const ConfigurationPtr config_;
 33 |   sample_mask_t sample_mask_;
 34 |   SpinLatch latch_;
 35 | 
 36 |   std::unique_ptr<TransactionEventMetrics> txn_event_metrics_;
 37 | };
 38 | 
 39 | extern thread_local std::shared_ptr<MetricsRepository> per_thread_metrics_repo;
 40 | 
 41 | /**
 42 |  * Handles thread registering, aggregates results, and output results to files
 43 |  */
 44 | class MetricsRepositoryManager {
 45 |  public:
 46 |   MetricsRepositoryManager(const std::string& config_name, const ConfigurationPtr& config);
 47 |   void RegisterCurrentThread();
 48 |   void AggregateAndFlushToDisk(const std::string& dir);
 49 | 
 50 |  private:
 51 |   const std::string config_name_;
 52 |   const ConfigurationPtr config_;
 53 |   sample_mask_t sample_mask_;
 54 |   std::unordered_map<std::thread::id, std::shared_ptr<MetricsRepository>> metrics_repos_;
 55 |   std::mutex mut_;
 56 | };
 57 | 
 58 | using MetricsRepositoryManagerPtr = std::shared_ptr<MetricsRepositoryManager>;
 59 | 
 60 | extern uint32_t gLocalMachineId;
 61 | extern uint64_t gEnabledEvents;
 62 | 
 63 | void InitializeRecording(const ConfigurationPtr& config);
 64 | 
 65 | template <typename TxnOrBatchInternalPtr>
 66 | inline void RecordTxnEvent(TxnOrBatchInternalPtr txn_internal, TransactionEvent event) {
 67 |   if (!((gEnabledEvents >> event) & 1)) {
 68 |     return;
 69 |   }
 70 |   if (txn_internal != nullptr) {
 71 |     auto now = std::chrono::system_clock::now().time_since_epoch().count();
 72 |     auto new_event = txn_internal->mutable_events()->Add();
 73 |     new_event->set_event(event);
 74 |     new_event->set_time(now);
 75 |     new_event->set_machine(gLocalMachineId);
 76 |     new_event->set_home(-1);
 77 |   }
 78 |   if (per_thread_metrics_repo != nullptr) {
 79 |     per_thread_metrics_repo->RecordTxnEvent(event);
 80 |   }
 81 | }
 82 | 
 83 | #ifdef ENABLE_TXN_EVENT_RECORDING
 84 | #define INIT_RECORDING(config) slog::InitializeRecording(config)
 85 | #define RECORD(txn, event) RecordTxnEvent(txn, event)
 86 | #else
 87 | #define INIT_RECORDING(config)
 88 | #define RECORD(txn, event)
 89 | #endif
 90 | 
 91 | // Helper function for quickly monitor throughput at a certain place
 92 | // TODO: use thread_local instead of static
 93 | #define MONITOR_THROUGHPUT()                                                                                \
 94 |   static int TP_COUNTER = 0;                                                                                \
 95 |   static int TP_LAST_COUNTER = 0;                                                                           \
 96 |   static std::chrono::steady_clock::time_point TP_LAST_LOG_TIME;                                            \
 97 |   TP_COUNTER++;                                                                                             \
 98 |   auto TP_LOG_SPAN = std::chrono::steady_clock::now() - TP_LAST_LOG_TIME;                                   \
 99 |   if (TP_LOG_SPAN > 1s) {                                                                                   \
100 |     LOG(INFO) << "Throughput: "                                                                             \
101 |               << (TP_COUNTER - TP_LAST_COUNTER) / std::chrono::duration_cast<seconds>(TP_LOG_SPAN).count(); \
102 |     TP_LAST_COUNTER = TP_COUNTER;                                                                           \
103 |     TP_LAST_LOG_TIME = std::chrono::steady_clock::now();                                                    \
104 |   }
105 | 
106 | }  // namespace slog


--------------------------------------------------------------------------------
/common/offline_data_reader.cpp:
--------------------------------------------------------------------------------
 1 | #include "common/offline_data_reader.h"
 2 | 
 3 | #include <glog/logging.h>
 4 | #include <google/protobuf/io/zero_copy_stream_impl.h>
 5 | 
 6 | using google::protobuf::io::CodedInputStream;
 7 | using google::protobuf::io::FileInputStream;
 8 | 
 9 | namespace slog {
10 | 
11 | OfflineDataReader::OfflineDataReader(int fd)
12 |     : raw_input_(new FileInputStream(fd)), coded_input_(new CodedInputStream(raw_input_)) {
13 |   if (!coded_input_->ReadVarint32(&num_datums_)) {
14 |     LOG(FATAL) << "Error while reading data file";
15 |   }
16 |   num_read_datums_ = 0;
17 | }
18 | 
19 | OfflineDataReader::~OfflineDataReader() {
20 |   delete coded_input_;
21 |   delete raw_input_;
22 | }
23 | 
24 | uint32_t OfflineDataReader::GetNumDatums() { return num_datums_; }
25 | 
26 | bool OfflineDataReader::HasNextDatum() { return num_read_datums_ < num_datums_; }
27 | 
28 | Datum OfflineDataReader::GetNextDatum() {
29 |   int sz;
30 |   // Read the size of the next datum
31 |   if (!coded_input_->ReadVarintSizeAsInt(&sz)) {
32 |     LOG(FATAL) << "Error while reading data file";
33 |   }
34 |   std::string buf;
35 |   // Read the datum given the size
36 |   if (!coded_input_->ReadString(&buf, sz)) {
37 |     LOG(FATAL) << "Error while reading data file";
38 |   }
39 | 
40 |   Datum datum;
41 |   // Parse raw bytes into protobuf object
42 |   datum.ParseFromString(buf);
43 | 
44 |   num_read_datums_++;
45 | 
46 |   return datum;
47 | }
48 | 
49 | }  // namespace slog


--------------------------------------------------------------------------------
/common/offline_data_reader.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <google/protobuf/io/coded_stream.h>
 4 | #include <google/protobuf/io/zero_copy_stream.h>
 5 | 
 6 | #include "proto/offline_data.pb.h"
 7 | 
 8 | namespace slog {
 9 | 
10 | class OfflineDataReader {
11 |  public:
12 |   OfflineDataReader(int fd);
13 |   ~OfflineDataReader();
14 | 
15 |   uint32_t GetNumDatums();
16 |   bool HasNextDatum();
17 |   Datum GetNextDatum();
18 | 
19 |  private:
20 |   google::protobuf::io::ZeroCopyInputStream* raw_input_;
21 |   google::protobuf::io::CodedInputStream* coded_input_;
22 |   uint32_t num_datums_;
23 |   uint32_t num_read_datums_;
24 | };
25 | 
26 | }  // namespace slog


--------------------------------------------------------------------------------
/common/proto_utils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <optional>
 4 | #include <unordered_map>
 5 | #include <vector>
 6 | 
 7 | #include "common/configuration.h"
 8 | #include "common/sharder.h"
 9 | #include "common/types.h"
10 | 
11 | #define ENUM_NAME(enum, enum_type) enum_type##_descriptor()->FindValueByNumber(enum)->name()
12 | #define CASE_NAME(case, type) type::descriptor()->FindFieldByNumber(case)->name()
13 | 
14 | using std::pair;
15 | using std::string;
16 | using std::unordered_map;
17 | 
18 | namespace slog {
19 | 
20 | struct KeyMetadata {
21 |   KeyMetadata(const Key& key, KeyType type = KeyType::READ, std::optional<Metadata> metadata = {})
22 |       : key(key), type(type), metadata(metadata) {}
23 | 
24 |   KeyMetadata(const Key& key, KeyType type, uint32_t master) : KeyMetadata(key, type, {{master}}) {}
25 | 
26 |   Key key;
27 |   KeyType type;
28 |   std::optional<Metadata> metadata;
29 | };
30 | 
31 | /**
32 |  * Creates a new transaction
33 |  * @param key_metadatas       Keys and metadata
34 |  * @param code                Code
35 |  * @param remaster            If specify, `code` is ignored and the txn becomes a remaster txn
36 |  * @param coordinating_server MachineId of the server in charge of responding the
37 |  *                            transaction result to the client.
38 |  * @return                    A new transaction having given properties
39 |  */
40 | Transaction* MakeTransaction(const std::vector<KeyMetadata>& key_metadatas,
41 |                              const std::vector<std::vector<std::string>>& code = {{}},
42 |                              std::optional<int> remaster = std::nullopt, MachineId coordinating_server = 0);
43 | 
44 | /**
45 |  * Inspects the internal metadata of a transaction then determines whether
46 |  * a transaction is SINGLE_HOME, MULTI_HOME, or UNKNOWN.
47 |  * Pre-condition: all keys in master_metadata exist in either write set or
48 |  * read set of the transaction
49 |  *
50 |  * @param txn The questioned transaction. Its `type` property will also be
51 |  *            set to the result.
52 |  * @return    The type of the given transaction.
53 |  */
54 | TransactionType SetTransactionType(Transaction& txn);
55 | 
56 | /**
57 |  * If in_place is set to true, the given txn is modified
58 |  */
59 | Transaction* GenerateLockOnlyTxn(Transaction* txn, uint32_t lo_master, bool in_place = false);
60 | 
61 | /**
62 |  * Returns nullptr if the generated txn contains no relevant key
63 |  */
64 | Transaction* GeneratePartitionedTxn(const SharderPtr& sharder, Transaction* txn, uint32_t partition,
65 |                                     bool in_place = false);
66 | 
67 | /**
68 |  * Populate the involved_replicas field in the transaction
69 |  */
70 | void PopulateInvolvedReplicas(Transaction& txn);
71 | 
72 | /**
73 |  * Populate the involved_partitions field in the transaction
74 |  */
75 | void PopulateInvolvedPartitions(const SharderPtr& sharder, Transaction& txn);
76 | 
77 | /**
78 |  * Merges the results of two transactions
79 |  *
80 |  * @param txn   The transaction that will hold the final merged result
81 |  * @param other The transaction to be merged with
82 |  */
83 | void MergeTransaction(Transaction& txn, const Transaction& other);
84 | 
85 | std::ostream& operator<<(std::ostream& os, const Transaction& txn);
86 | std::ostream& operator<<(std::ostream& os, const MasterMetadata& metadata);
87 | 
88 | bool operator==(const MasterMetadata& metadata1, const MasterMetadata& metadata2);
89 | bool operator==(const ValueEntry& val1, const ValueEntry& val2);
90 | bool operator==(const KeyValueEntry& kv1, const KeyValueEntry& kv2);
91 | bool operator==(const Transaction& txn1, const Transaction txn2);
92 | 
93 | /**
94 |  * Extract txns from a batch
95 |  */
96 | std::vector<Transaction*> Unbatch(internal::Batch* batch);
97 | 
98 | }  // namespace slog


--------------------------------------------------------------------------------
/common/sharder.cpp:
--------------------------------------------------------------------------------
 1 | #include "common/sharder.h"
 2 | 
 3 | namespace slog {
 4 | 
 5 | namespace {
 6 | 
 7 | template <class It>
 8 | uint32_t FNVHash(It begin, It end) {
 9 |   uint64_t hash = 0x811c9dc5;
10 |   for (auto it = begin; it != end; it++) {
11 |     hash = (hash * 0x01000193) % (1LL << 32);
12 |     hash ^= *it;
13 |   }
14 |   return hash;
15 | }
16 | 
17 | }  // namespace
18 | 
19 | std::shared_ptr<Sharder> Sharder::MakeSharder(const ConfigurationPtr& config) {
20 |   if (config->proto_config().has_simple_partitioning()) {
21 |     return std::make_shared<SimpleSharder>(config);
22 |   } else if (config->proto_config().has_tpcc_partitioning()) {
23 |     return std::make_shared<TPCCSharder>(config);
24 |   }
25 |   return std::make_shared<HashSharder>(config);
26 | }
27 | 
28 | Sharder::Sharder(const ConfigurationPtr& config)
29 |     : local_partition_(config->local_partition()), num_partitions_(config->num_partitions()) {}
30 | 
31 | bool Sharder::is_local_key(const Key& key) const { return compute_partition(key) == local_partition_; }
32 | 
33 | uint32_t Sharder::num_partitions() const { return num_partitions_; }
34 | 
35 | uint32_t Sharder::local_partition() const { return local_partition_; }
36 | 
37 | HashSharder::HashSharder(const ConfigurationPtr& config)
38 |     : Sharder(config), partition_key_num_bytes_(config->proto_config().hash_partitioning().partition_key_num_bytes()) {}
39 | 
40 | uint32_t HashSharder::compute_partition(const Key& key) const {
41 |   auto end = partition_key_num_bytes_ >= key.length() ? key.end() : key.begin() + partition_key_num_bytes_;
42 |   return FNVHash(key.begin(), end) % num_partitions_;
43 | }
44 | 
45 | SimpleSharder::SimpleSharder(const ConfigurationPtr& config) : Sharder(config) {}
46 | 
47 | uint32_t SimpleSharder::compute_partition(const Key& key) const { return std::stoll(key) % num_partitions_; }
48 | 
49 | TPCCSharder::TPCCSharder(const ConfigurationPtr& config) : Sharder(config) {}
50 | uint32_t TPCCSharder::compute_partition(const Key& key) const {
51 |   int w_id = *reinterpret_cast<const int*>(key.data());
52 |   return (w_id - 1) % num_partitions_;
53 | }
54 | 
55 | }  // namespace slog


--------------------------------------------------------------------------------
/common/sharder.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "common/configuration.h"
 4 | #include "common/types.h"
 5 | 
 6 | namespace slog {
 7 | 
 8 | class Sharder;
 9 | 
10 | using SharderPtr = std::shared_ptr<Sharder>;
11 | 
12 | class Sharder {
13 |  public:
14 |   static std::shared_ptr<Sharder> MakeSharder(const ConfigurationPtr& config);
15 | 
16 |   Sharder(const ConfigurationPtr& config);
17 | 
18 |   bool is_local_key(const Key& key) const;
19 |   uint32_t num_partitions() const;
20 |   uint32_t local_partition() const;
21 | 
22 |   virtual uint32_t compute_partition(const Key& key) const = 0;
23 | 
24 |  protected:
25 |   uint32_t local_partition_;
26 |   uint32_t num_partitions_;
27 | };
28 | 
29 | class HashSharder : public Sharder {
30 |  public:
31 |   HashSharder(const ConfigurationPtr& config);
32 |   uint32_t compute_partition(const Key& key) const final;
33 | 
34 |  private:
35 |   size_t partition_key_num_bytes_;
36 | };
37 | 
38 | class SimpleSharder : public Sharder {
39 |  public:
40 |   SimpleSharder(const ConfigurationPtr& config);
41 |   uint32_t compute_partition(const Key& key) const final;
42 | };
43 | 
44 | class TPCCSharder : public Sharder {
45 |  public:
46 |   TPCCSharder(const ConfigurationPtr& config);
47 |   uint32_t compute_partition(const Key& key) const final;
48 | };
49 | 
50 | }  // namespace slog


--------------------------------------------------------------------------------
/common/spin_latch.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <atomic>
 4 | 
 5 | // See https://rigtorp.se/spinlock/
 6 | class SpinLatch {
 7 |  public:
 8 |   void lock() {
 9 |     for (;;) {
10 |       if (!lock_.exchange(true)) {
11 |         break;
12 |       }
13 |       while (lock_.load())
14 |         ;
15 |     };
16 |   }
17 | 
18 |   void unlock() { lock_.store(false); }
19 | 
20 |  private:
21 |   std::atomic<bool> lock_ = {false};
22 | };
23 | 


--------------------------------------------------------------------------------
/common/string_utils.cpp:
--------------------------------------------------------------------------------
 1 | #include "common/string_utils.h"
 2 | 
 3 | #include <algorithm>
 4 | 
 5 | namespace slog {
 6 | 
 7 | using std::string;
 8 | using std::vector;
 9 | 
10 | size_t NextToken(string& token, const string& str, const string& delims, size_t pos) {
11 |   auto start = str.find_first_not_of(delims, pos);
12 |   if (start == string::npos) {
13 |     token = "";
14 |     return string::npos;
15 |   }
16 |   auto end = str.find_first_of(delims, start);
17 |   if (end == string::npos) {
18 |     end = str.length();
19 |   }
20 |   token = str.substr(start, end - start);
21 |   return start + token.length();
22 | }
23 | 
24 | size_t NextNTokens(vector<string>& tokens, const string& str, const string& delims, size_t n, size_t pos) {
25 |   tokens.clear();
26 |   for (size_t i = 0; i < n; i++) {
27 |     string token;
28 |     pos = NextToken(token, str, delims, pos);
29 |     if (pos == string::npos) {
30 |       tokens.clear();
31 |       return string::npos;
32 |     }
33 |     tokens.push_back(std::move(token));
34 |   }
35 |   return pos;
36 | }
37 | 
38 | string Trim(string str) {
39 |   // trim left
40 |   auto it = str.begin();
41 |   while (it != str.end() && std::isspace(*it)) {
42 |     it++;
43 |   }
44 |   str.erase(str.begin(), it);
45 | 
46 |   // trim right
47 |   auto rit = str.rbegin();
48 |   while (rit != str.rend() && std::isspace(*rit)) {
49 |     rit++;
50 |   }
51 |   str.erase(rit.base(), str.end());
52 | 
53 |   return str;
54 | }
55 | 
56 | vector<string> Split(const std::string& str, const std::string& delims) {
57 |   vector<string> res;
58 |   string token;
59 |   size_t pos = NextToken(token, str, delims, 0);
60 |   while (pos != std::string::npos) {
61 |     res.push_back(token);
62 |     pos = NextToken(token, str, delims, pos);
63 |   }
64 |   return res;
65 | }
66 | 
67 | const std::string RandomStringGenerator::kCharacters("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ");
68 | 
69 | RandomStringGenerator::RandomStringGenerator(int seed, size_t pool_size) : rg_(seed), rnd_str_pool_offset_(0) {
70 |   rnd_str_pool_.reserve(pool_size);
71 |   std::uniform_int_distribution<uint32_t> char_rnd(0, kCharacters.size() - 1);
72 |   for (size_t i = 0; i < pool_size; i++) {
73 |     rnd_str_pool_.push_back(kCharacters[char_rnd(rg_)]);
74 |   }
75 | }
76 | 
77 | std::string RandomStringGenerator::operator()(size_t len) {
78 |   if (rnd_str_pool_offset_ + len >= rnd_str_pool_.size()) {
79 |     rnd_str_pool_offset_ = 0;
80 |   }
81 |   auto res = rnd_str_pool_.substr(rnd_str_pool_offset_, len);
82 |   rnd_str_pool_offset_ += len;
83 |   return res;
84 | }
85 | 
86 | }  // namespace slog


--------------------------------------------------------------------------------
/common/string_utils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <random>
 4 | #include <sstream>
 5 | #include <string>
 6 | #include <vector>
 7 | 
 8 | namespace slog {
 9 | 
10 | size_t NextToken(std::string& token, const std::string& str, const std::string& delims, size_t pos = 0);
11 | 
12 | size_t NextNTokens(std::vector<std::string>& tokens, const std::string& str, const std::string& delims, size_t n = 1,
13 |                    size_t pos = 0);
14 | 
15 | std::string Trim(std::string str);
16 | 
17 | std::vector<std::string> Split(const std::string& str, const std::string& delims);
18 | 
19 | template <template <typename, typename...> class Container, typename T, typename R>
20 | std::string Join(const Container<std::pair<T, R>>& parts, char delim = ';') {
21 |   std::ostringstream ss;
22 |   bool first = true;
23 |   for (const auto& p : parts) {
24 |     if (!first) {
25 |       ss << delim;
26 |     } else {
27 |       first = false;
28 |     }
29 |     ss << p.first << ":" << p.second;
30 |   }
31 |   return ss.str();
32 | }
33 | 
34 | template <typename Container>
35 | std::string Join(const Container& parts, char delim = ';') {
36 |   std::ostringstream ss;
37 |   bool first = true;
38 |   for (const auto& p : parts) {
39 |     if (!first) {
40 |       ss << delim;
41 |     } else {
42 |       first = false;
43 |     }
44 |     ss << p;
45 |   }
46 |   return ss.str();
47 | }
48 | 
49 | class RandomStringGenerator {
50 |  public:
51 |   RandomStringGenerator(int seed = 0, size_t pool_size = 100000);
52 |   std::string operator()(size_t len);
53 | 
54 |  private:
55 |   const static std::string kCharacters;
56 | 
57 |   std::mt19937 rg_;
58 |   size_t rnd_str_pool_offset_;
59 |   std::string rnd_str_pool_;
60 | };
61 | 
62 | }  // namespace slog


--------------------------------------------------------------------------------
/common/thread_utils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <glog/logging.h>
 4 | 
 5 | #include <chrono>
 6 | #include <thread>
 7 | 
 8 | namespace slog {
 9 | 
10 | inline void SetThreadName(pthread_t thread, const char* name) { pthread_setname_np(thread, name); }
11 | 
12 | inline void PinToCpu(pthread_t thread, int cpu) {
13 |   cpu_set_t cpuset;
14 |   CPU_ZERO(&cpuset);
15 |   CPU_SET(cpu, &cpuset);
16 |   int rc = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
17 |   if (rc != 0) {
18 |     LOG(ERROR) << "Failed to pin thread to CPU " << cpu << ". Error code: " << rc;
19 |   }
20 | }
21 | 
22 | }  // namespace slog


--------------------------------------------------------------------------------
/common/types.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | 
 5 | #include "proto/transaction.pb.h"
 6 | 
 7 | namespace slog {
 8 | 
 9 | using Key = std::string;
10 | using KeyReplica = std::string;
11 | using Value = std::string;
12 | using TxnId = uint64_t;
13 | using BatchId = uint64_t;
14 | using SlotId = uint32_t;
15 | using Channel = uint64_t;
16 | using MachineId = int;
17 | 
18 | struct Metadata {
19 |   Metadata() = default;
20 |   Metadata(const MasterMetadata& metadata) : master(metadata.master()), counter(metadata.counter()) {}
21 |   Metadata(uint32_t m, uint32_t c = 0) : master(m), counter(c) {}
22 |   void operator=(const MasterMetadata& metadata) {
23 |     master = metadata.master();
24 |     counter = metadata.counter();
25 |   }
26 | 
27 |   uint32_t master = 0;
28 |   uint32_t counter = 0;
29 | };
30 | 
31 | struct Record {
32 |   Record(const std::string& v, uint32_t m = 0, uint32_t c = 0) : metadata_(m, c) { SetValue(v); }
33 | 
34 |   Record(const Record& other) {
35 |     SetValue(other.data_.get(), other.size_);
36 |     SetMetadata(other.metadata_);
37 |   }
38 | 
39 |   Record& operator=(const Record& other) {
40 |     Record tmp(other);
41 |     data_.swap(tmp.data_);
42 |     std::swap(size_, tmp.size_);
43 |     std::swap(metadata_, tmp.metadata_);
44 |     return *this;
45 |   }
46 | 
47 |   void SetMetadata(const Metadata& metadata) { metadata_ = metadata; }
48 | 
49 |   void SetValue(const std::string& v) { SetValue(v.data(), v.size()); }
50 | 
51 |   void SetValue(const char* data, size_t size) {
52 |     size_ = size;
53 |     data_.reset(new char[size_]);
54 |     memcpy(data_.get(), data, size_);
55 |   }
56 | 
57 |   std::string to_string() const {
58 |     if (data_ == nullptr) {
59 |       return "";
60 |     }
61 |     return std::string(data_.get(), size_);
62 |   }
63 | 
64 |   Record() = default;
65 | 
66 |   const Metadata& metadata() const { return metadata_; }
67 |   char* data() { return data_.get(); }
68 |   size_t size() { return size_; }
69 | 
70 |  private:
71 |   Metadata metadata_;
72 |   std::unique_ptr<char[]> data_;
73 |   size_t size_ = 0;
74 | };
75 | 
76 | enum class LockMode { UNLOCKED, READ, WRITE };
77 | enum class AcquireLocksResult { ACQUIRED, WAITING, ABORT };
78 | 
79 | inline KeyReplica MakeKeyReplica(const Key& key, uint32_t master) {
80 |   std::string new_key;
81 |   auto master_str = std::to_string(master);
82 |   new_key.reserve(key.length() + master_str.length() + 1);
83 |   new_key += key;
84 |   new_key += ":";
85 |   new_key += master_str;
86 |   return new_key;
87 | }
88 | 
89 | }  // namespace slog


--------------------------------------------------------------------------------
/connection/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | target_sources(slog-core
 2 |   PRIVATE
 3 |     broker.cpp
 4 |     broker.h
 5 |     poller.cpp
 6 |     poller.h
 7 |     sender.cpp
 8 |     sender.h
 9 |     zmq_utils.h)
10 | 


--------------------------------------------------------------------------------
/connection/broker.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <condition_variable>
 4 | #include <thread>
 5 | #include <unordered_map>
 6 | #include <zmq.hpp>
 7 | 
 8 | #include "common/configuration.h"
 9 | #include "common/constants.h"
10 | #include "common/types.h"
11 | #include "connection/zmq_utils.h"
12 | #include "module/base/module.h"
13 | 
14 | namespace slog {
15 | 
16 | /**
17 |  * A Broker distributes messages coming into a machine to the modules
18 |  * It runs its own thread with the components depicted below
19 |  *
20 |  *                   --------------------------
21 |  *                   |                        |
22 |  *  Module A <---- Channel A                Router  <----- Incoming Messages
23 |  *                   |          B             |
24 |  *                   |           R            |
25 |  *  Module B <---- Channel B      O           |
26 |  *                   |             K          |
27 |  *                   |              E         |
28 |  *  Module C <---- Channel C         R        |
29 |  *                   |                        |
30 |  *                   |                        |
31 |  *                   --------------------------
32 |  *
33 |  *  Module A  ------> Sender -----------------------> Outgoing Messages
34 |  *
35 |  *  Module B  ----------------> Sender -------------> Outgoing Messages
36 |  *
37 |  *  Module C  --------------------------> Sender ---> Outgoing Messages
38 |  *
39 |  *
40 |  * To receive messages from other machines, it uses a ZMQ_ROUTER socket, which constructs
41 |  * a map from an identity to the corresponding connection. Using this identity, it can
42 |  * tell where the message comes from.
43 |  *
44 |  * The messages going into the system via the router will be brokered to the channel
45 |  * specified in each message. On the other end of each channel is a module which also runs
46 |  * in its own thread.
47 |  *
48 |  * A module sends message to another machine via a Sender object. Not showed above: the modules
49 |  * can send message to each other using Sender without going through the Broker.
50 |  */
51 | class Broker {
52 |  public:
53 |   static std::shared_ptr<Broker> New(const ConfigurationPtr& config,
54 |                                      std::chrono::milliseconds poll_timeout_ms = kModuleTimeout, bool blocky = false);
55 | 
56 |   static Channel MakeChannel(int broker_num) { return kBrokerChannel + broker_num; }
57 | 
58 |   void StartInNewThreads();
59 |   void Stop();
60 | 
61 |   void AddChannel(Channel chan, bool send_raw = false);
62 | 
63 |   const ConfigurationPtr& config() const { return config_; }
64 |   const std::shared_ptr<zmq::context_t>& context() const { return context_; }
65 | 
66 |  private:
67 |   Broker(const ConfigurationPtr& config, const std::shared_ptr<zmq::context_t>& context,
68 |          std::chrono::milliseconds poll_timeout_ms);
69 | 
70 |   ConfigurationPtr config_;
71 |   std::shared_ptr<zmq::context_t> context_;
72 |   std::chrono::milliseconds poll_timeout_ms_;
73 | 
74 |   bool running_;
75 |   std::vector<std::pair<Channel, bool>> channels_;
76 |   std::vector<std::unique_ptr<slog::ModuleRunner>> threads_;
77 | };
78 | 
79 | }  // namespace slog


--------------------------------------------------------------------------------
/connection/poller.cpp:
--------------------------------------------------------------------------------
 1 | #include "connection/poller.h"
 2 | 
 3 | using namespace std::chrono;
 4 | 
 5 | using std::optional;
 6 | using std::vector;
 7 | 
 8 | namespace slog {
 9 | 
10 | Poller::Poller(optional<microseconds> timeout) : poll_timeout_(timeout) {}
11 | 
12 | void Poller::PushSocket(zmq::socket_t& socket) {
13 |   poll_items_.push_back({
14 |       socket.handle(), 0, /* fd */
15 |       ZMQ_POLLIN, 0       /* revent */
16 |   });
17 | }
18 | 
19 | bool Poller::NextEvent(bool dont_wait) {
20 |   auto may_have_msg = true;
21 |   if (!dont_wait) {
22 |     // Compute the time that we need to wait until the next event
23 |     auto shortest_timeout = poll_timeout_;
24 |     auto now = Clock::now();
25 |     for (auto& ev : timed_callbacks_) {
26 |       if (ev.when <= now) {
27 |         shortest_timeout = 0us;
28 |         break;
29 |       } else if (!shortest_timeout.has_value() || ev.when - now < shortest_timeout.value()) {
30 |         shortest_timeout = duration_cast<microseconds>(ev.when - now);
31 |       }
32 |     }
33 | 
34 |     int rc = 0;
35 |     // Wait until the next time event or some timeout.
36 |     if (shortest_timeout.has_value()) {
37 |       // By casting the timeout from microseconds to milliseconds, if it is below 1ms,
38 |       // the casting result will be 0 and thus poll becomes non-blocking. This is intended
39 |       // so that we spin wait instead of sleeping, making waiting more accurate.
40 |       rc = zmq::poll(poll_items_, duration_cast<milliseconds>(shortest_timeout.value()));
41 |     } else {
42 |       // No timed event to wait, wait until there is a new message
43 |       rc = zmq::poll(poll_items_, -1);
44 |     }
45 |     may_have_msg = rc > 0;
46 |   }
47 | 
48 |   // Process and clean up triggered callbacks
49 |   if (!timed_callbacks_.empty()) {
50 |     auto now = Clock::now();
51 |     for (auto it = timed_callbacks_.begin(); it != timed_callbacks_.end();) {
52 |       if (it->when <= now) {
53 |         it->callback();
54 |         it = timed_callbacks_.erase(it);
55 |       } else {
56 |         ++it;
57 |       }
58 |     }
59 |   }
60 | 
61 |   return may_have_msg;
62 | }
63 | 
64 | bool Poller::is_socket_ready(size_t i) const { return poll_items_[i].revents & ZMQ_POLLIN; }
65 | 
66 | void Poller::AddTimedCallback(microseconds timeout, std::function<void()>&& cb) {
67 |   timed_callbacks_.push_back({.when = Clock::now() + timeout, .callback = move(cb)});
68 | }
69 | 
70 | }  // namespace slog


--------------------------------------------------------------------------------
/connection/poller.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <functional>
 4 | #include <list>
 5 | #include <optional>
 6 | #include <vector>
 7 | #include <zmq.hpp>
 8 | 
 9 | namespace slog {
10 | 
11 | class Poller {
12 |  public:
13 |   Poller(std::optional<std::chrono::microseconds> timeout);
14 | 
15 |   // Returns true if it is possible that there is a message in one of the sockets
16 |   // If dont_wait is set to true, this always return true
17 |   bool NextEvent(bool dont_wait = false);
18 | 
19 |   void PushSocket(zmq::socket_t& socket);
20 | 
21 |   bool is_socket_ready(size_t i) const;
22 | 
23 |   void AddTimedCallback(std::chrono::microseconds timeout, std::function<void()>&& cb);
24 | 
25 |  private:
26 |   using Clock = std::chrono::steady_clock;
27 |   using TimePoint = Clock::time_point;
28 |   struct TimedCallback {
29 |     TimePoint when;
30 |     std::function<void()> callback;
31 |   };
32 | 
33 |   std::optional<std::chrono::microseconds> poll_timeout_;
34 |   std::vector<zmq::pollitem_t> poll_items_;
35 |   std::list<TimedCallback> timed_callbacks_;
36 | };
37 | 
38 | }  // namespace slog


--------------------------------------------------------------------------------
/connection/sender.cpp:
--------------------------------------------------------------------------------
 1 | #include "sender.h"
 2 | 
 3 | using std::move;
 4 | 
 5 | namespace slog {
 6 | 
 7 | Sender::Sender(const ConfigurationPtr& config, const std::shared_ptr<zmq::context_t>& context, bool is_long)
 8 |     : config_(config), context_(context), is_long_(is_long) {}
 9 | 
10 | void Sender::Send(const internal::Envelope& envelope, MachineId to_machine_id, Channel to_channel) {
11 |   auto& socket = GetRemoteSocket(to_machine_id, to_channel);
12 |   SendSerializedProto(*socket, envelope, config_->local_machine_id(), to_channel);
13 | }
14 | 
15 | void Sender::Send(EnvelopePtr&& envelope, MachineId to_machine_id, Channel to_channel) {
16 |   if (to_machine_id == config_->local_machine_id()) {
17 |     Send(move(envelope), to_channel);
18 |   } else {
19 |     Send(*envelope, to_machine_id, to_channel);
20 |   }
21 | }
22 | 
23 | void Sender::Send(EnvelopePtr&& envelope, Channel to_channel) {
24 |   // Lazily establish a new connection when necessary
25 |   auto it = local_channel_to_socket_.find(to_channel);
26 |   if (it == local_channel_to_socket_.end()) {
27 |     zmq::socket_t new_socket(*context_, ZMQ_PUSH);
28 |     new_socket.connect(MakeInProcChannelAddress(to_channel));
29 |     new_socket.set(zmq::sockopt::sndhwm, 0);
30 |     auto res = local_channel_to_socket_.insert_or_assign(to_channel, move(new_socket));
31 |     it = res.first;
32 |   }
33 |   envelope->set_from(config_->local_machine_id());
34 |   SendEnvelope(it->second, move(envelope));
35 | }
36 | 
37 | void Sender::Send(const internal::Envelope& envelope, const std::vector<MachineId>& to_machine_ids,
38 |                   Channel to_channel) {
39 |   auto serialized = SerializeProto(envelope);
40 |   for (auto dest : to_machine_ids) {
41 |     zmq::message_t copied;
42 |     copied.copy(serialized);
43 |     auto& socket = GetRemoteSocket(dest, to_channel);
44 |     SendAddressedBuffer(*socket, move(copied), config_->local_machine_id(), to_channel);
45 |   }
46 | }
47 | 
48 | void Sender::Send(EnvelopePtr&& envelope, const std::vector<MachineId>& to_machine_ids, Channel to_channel) {
49 |   auto serialized = SerializeProto(*envelope);
50 |   bool send_local = false;
51 |   for (auto dest : to_machine_ids) {
52 |     if (dest == config_->local_machine_id()) {
53 |       send_local = true;
54 |       continue;
55 |     }
56 |     zmq::message_t copied;
57 |     copied.copy(serialized);
58 |     auto& socket = GetRemoteSocket(dest, to_channel);
59 |     SendAddressedBuffer(*socket, move(copied), config_->local_machine_id(), to_channel);
60 |   }
61 |   if (send_local) {
62 |     Send(std::move(envelope), to_channel);
63 |   }
64 | }
65 | 
66 | Sender::SocketPtr& Sender::GetRemoteSocket(MachineId machine_id, Channel channel) {
67 |   uint32_t port;
68 |   if (channel >= kMaxChannel) {
69 |     port = config_->broker_ports(config_->broker_ports_size() - 1);
70 |   } else {
71 |     switch (channel) {
72 |       case kForwarderChannel:
73 |         port = config_->forwarder_port();
74 |         break;
75 |       case kSequencerChannel:
76 |         port = config_->sequencer_port();
77 |         break;
78 |       default:
79 |         port = config_->broker_ports(0);
80 |     }
81 |   }
82 | 
83 |   // Lazily establish a new connection when necessary
84 |   uint64_t machine_id_and_port = (static_cast<uint64_t>(machine_id) << 32) | port;
85 |   auto ins = machine_id_and_port_to_sockets_.try_emplace(machine_id_and_port, nullptr);
86 |   auto& socket = ins.first->second;
87 |   if (socket == nullptr) {
88 |     socket = std::make_unique<zmq::socket_t>(*context_, ZMQ_PUSH);
89 |     socket->set(zmq::sockopt::sndhwm, 0);
90 |     if (is_long_) {
91 |       socket->set(zmq::sockopt::sndbuf, config_->long_sender_sndbuf());
92 |     }
93 |     auto endpoint = MakeRemoteAddress(config_->protocol(), config_->address(machine_id), port);
94 |     socket->connect(endpoint);
95 |   }
96 |   return socket;
97 | }
98 | 
99 | }  // namespace slog


--------------------------------------------------------------------------------
/connection/sender.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <unordered_map>
 4 | #include <zmq.hpp>
 5 | 
 6 | #include "common/types.h"
 7 | #include "connection/broker.h"
 8 | #include "connection/zmq_utils.h"
 9 | #include "proto/internal.pb.h"
10 | 
11 | namespace slog {
12 | 
13 | /*
14 |  * See Broker class for details about this class
15 |  */
16 | class Sender {
17 |  public:
18 |   Sender(const ConfigurationPtr& config, const std::shared_ptr<zmq::context_t>& context, bool is_long = false);
19 | 
20 |   /**
21 |    * Send a request or response to a given channel of a given machine
22 |    * @param envelope Request or response to be sent
23 |    * @param to_machine_id Id of the machine that this message is sent to
24 |    * @param to_channel Channel on the machine that this message is sent to
25 |    */
26 |   void Send(const internal::Envelope& envelope, MachineId to_machine_id, Channel to_channel);
27 | 
28 |   /**
29 |    * Send a request or response to a given channel of a given machine. Use local send
30 |    * if the destination machine is the local machine
31 |    * @param envelope Request or response to be sent
32 |    * @param to_machine_id Id of the machine that this message is sent to
33 |    * @param to_channel Channel on the machine that this message is sent to
34 |    */
35 |   void Send(EnvelopePtr&& envelope, MachineId to_machine_id, Channel to_channel);
36 | 
37 |   /**
38 |    * Send a request or response to the same machine given a channel
39 |    * @param request_or_response Request or response to be sent
40 |    * @param to_channel Channel on the machine that this message is sent to
41 |    */
42 |   void Send(EnvelopePtr&& envelope, Channel to_channel);
43 | 
44 |   /**
45 |    * Send a request or response to a given channel of a list of machines.
46 |    * Use this to serialize the message only once.
47 |    * @param request_or_response Request or response to be sent
48 |    * @param to_machine_ids Ids of the machines that this message is sent to
49 |    * @param to_channel Channel on the machine that this message is sent to
50 |    */
51 |   void Send(const internal::Envelope& envelope, const std::vector<MachineId>& to_machine_ids, Channel to_channel);
52 | 
53 |   /**
54 |    * Send a request or response to a given channel of a list of machines.
55 |    * If local machine is among the destination, local send is used for that machine.
56 |    * Use this to serialize the message only once.
57 |    * @param request_or_response Request or response to be sent
58 |    * @param to_machine_ids Ids of the machines that this message is sent to
59 |    * @param to_channel Channel on the machine that this message is sent to
60 |    */
61 |   void Send(EnvelopePtr&& envelope, const std::vector<MachineId>& to_machine_ids, Channel to_channel);
62 | 
63 |  private:
64 |   using SocketPtr = std::unique_ptr<zmq::socket_t>;
65 |   SocketPtr& GetRemoteSocket(MachineId machine_id, Channel channel);
66 | 
67 |   ConfigurationPtr config_;
68 |   // Keep a pointer to context here to make sure that the below sockets
69 |   // are destroyed before the context is
70 |   std::shared_ptr<zmq::context_t> context_;
71 |   // Sockets of a long sender have a larger kernel buffer size
72 |   bool is_long_;
73 |   std::unordered_map<uint64_t, SocketPtr> machine_id_and_port_to_sockets_;
74 |   std::unordered_map<Channel, zmq::socket_t> local_channel_to_socket_;
75 | };
76 | 
77 | }  // namespace slog


--------------------------------------------------------------------------------
/data_structure/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | target_sources(slog-core
2 |   PRIVATE
3 |     async_log.h
4 |     batch_log.cpp
5 |     batch_log.h
6 |     concurrent_hash_map.h
7 |     rwlatch.h)


--------------------------------------------------------------------------------
/data_structure/async_log.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <sstream>
 4 | #include <unordered_map>
 5 | 
 6 | namespace slog {
 7 | 
 8 | /**
 9 |  * This data structure is a log of items numbered consecutively in
10 |  * an increasing order.
11 |  *
12 |  * Items can be added in any order but they are iterated one-by-one
13 |  * following their number. In other words, if the item right after the
14 |  * most recently read item has not been added to the log, read cannot
15 |  * advance. A log can only be iterated forward in one direction.
16 |  */
17 | template <typename T>
18 | class AsyncLog {
19 |  public:
20 |   AsyncLog(uint32_t start_from = 0) : next_(start_from) {}
21 | 
22 |   void Insert(uint32_t position, const T& item) {
23 |     if (position < next_) {
24 |       return;
25 |     }
26 |     auto ret = log_.emplace(position, item);
27 |     if (ret.second == false) {
28 |       std::ostringstream os;
29 |       os << "Log position " << position << " has already been taken";
30 |       throw std::runtime_error(os.str());
31 |     }
32 |   }
33 | 
34 |   bool HasNext() const { return log_.count(next_) > 0; }
35 | 
36 |   const T& Peek() { return log_.at(next_); }
37 | 
38 |   std::pair<uint32_t, T> Next() {
39 |     if (!HasNext()) {
40 |       throw std::runtime_error("Next item does not exist");
41 |     }
42 |     auto position = next_;
43 |     next_++;
44 | 
45 |     auto it = log_.find(position);
46 |     auto res = *it;
47 |     log_.erase(it);
48 |     return res;
49 |   }
50 | 
51 |   /* For debugging */
52 |   size_t NumBufferredItems() const { return log_.size(); }
53 | 
54 |  private:
55 |   std::unordered_map<uint32_t, T> log_;
56 |   uint32_t next_;
57 | };
58 | 
59 | }  // namespace slog


--------------------------------------------------------------------------------
/data_structure/batch_log.cpp:
--------------------------------------------------------------------------------
 1 | #include "data_structure/batch_log.h"
 2 | 
 3 | #include <glog/logging.h>
 4 | 
 5 | using std::make_pair;
 6 | using std::move;
 7 | 
 8 | namespace slog {
 9 | 
10 | BatchLog::BatchLog() {}
11 | 
12 | void BatchLog::AddBatch(BatchPtr&& batch) {
13 |   auto batch_id = batch->id();
14 |   batches_.insert_or_assign(batch_id, move(batch));
15 |   UpdateReadyBatches();
16 | }
17 | 
18 | void BatchLog::AckReplication(BatchId batch_id) {
19 |   replication_[batch_id]--;
20 |   UpdateReadyBatches();
21 | }
22 | 
23 | void BatchLog::AddSlot(SlotId slot_id, BatchId batch_id, int replication_factor) {
24 |   slots_.Insert(slot_id, batch_id);
25 |   replication_[batch_id] += replication_factor;
26 |   UpdateReadyBatches();
27 | }
28 | 
29 | bool BatchLog::HasNextBatch() const { return !ready_batches_.empty(); }
30 | 
31 | std::pair<SlotId, BatchPtr> BatchLog::NextBatch() {
32 |   if (!HasNextBatch()) {
33 |     throw std::runtime_error("NextBatch() was called when there is no ready batch");
34 |   }
35 |   auto next_slot = ready_batches_.front().first;
36 |   auto next_batch_id = ready_batches_.front().second;
37 |   ready_batches_.pop();
38 | 
39 |   auto it = batches_.find(next_batch_id);
40 |   auto res = make_pair(move(next_slot), move(it->second));
41 |   batches_.erase(it);
42 | 
43 |   return res;
44 | }
45 | 
46 | void BatchLog::UpdateReadyBatches() {
47 |   while (slots_.HasNext()) {
48 |     auto next_batch_id = slots_.Peek();
49 |     auto batch_it = batches_.find(next_batch_id);
50 |     auto rep_it = replication_.find(next_batch_id);
51 |     if (batch_it != batches_.end() && rep_it != replication_.end() && rep_it->second == 0) {
52 |       replication_.erase(rep_it);
53 |       ready_batches_.push(slots_.Next());
54 |     } else {
55 |       break;
56 |     }
57 |   }
58 | }
59 | 
60 | }  // namespace slog


--------------------------------------------------------------------------------
/data_structure/batch_log.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <queue>
 4 | #include <unordered_map>
 5 | 
 6 | #include "common/types.h"
 7 | #include "data_structure/async_log.h"
 8 | #include "proto/internal.pb.h"
 9 | 
10 | namespace slog {
11 | 
12 | using BatchPtr = std::unique_ptr<internal::Batch>;
13 | 
14 | class BatchLog {
15 |  public:
16 |   BatchLog();
17 | 
18 |   void AddBatch(BatchPtr&& batch);
19 |   void AddSlot(SlotId slot_id, BatchId batch_id, int replication_factor = 0);
20 |   void AckReplication(BatchId batch_id);
21 | 
22 |   bool HasNextBatch() const;
23 |   std::pair<SlotId, BatchPtr> NextBatch();
24 | 
25 |   /* For debugging */
26 |   size_t NumBufferedSlots() const { return slots_.NumBufferredItems(); }
27 | 
28 |   /* For debugging */
29 |   size_t NumBufferedBatches() const { return batches_.size(); }
30 | 
31 |  private:
32 |   void UpdateReadyBatches();
33 | 
34 |   AsyncLog<BatchId> slots_;
35 |   std::unordered_map<BatchId, BatchPtr> batches_;
36 |   std::unordered_map<BatchId, int> replication_;
37 |   std::queue<std::pair<SlotId, BatchId>> ready_batches_;
38 | };
39 | 
40 | }  // namespace slog


--------------------------------------------------------------------------------
/data_structure/rwlatch.h:
--------------------------------------------------------------------------------
  1 | // Originally from CMU's BusTub project:
  2 | // https://github.com/cmu-db/bustub/edit/master/src/include/common/rwlatch.h
  3 | //
  4 | // Slightly modified to work with this project.
  5 | //===----------------------------------------------------------------------===//
  6 | //
  7 | //                         BusTub
  8 | //
  9 | // rwmutex.h
 10 | //
 11 | // Copyright (c) 2015-2019, Carnegie Mellon University Database Group
 12 | //
 13 | //===----------------------------------------------------------------------===//
 14 | 
 15 | #pragma once
 16 | 
 17 | #include <climits>
 18 | #include <condition_variable>  // NOLINT
 19 | #include <mutex>               // NOLINT
 20 | 
 21 | // Macros to disable copying and moving
 22 | #define DISALLOW_COPY(cname)                             \
 23 |   cname(const cname &) = delete;            /* NOLINT */ \
 24 |   cname &operator=(const cname &) = delete; /* NOLINT */
 25 | 
 26 | namespace bustub {
 27 | 
 28 | /**
 29 |  * Reader-Writer latch backed by std::mutex.
 30 |  */
 31 | class ReaderWriterLatch {
 32 |   using mutex_t = std::mutex;
 33 |   using cond_t = std::condition_variable;
 34 |   static const uint32_t MAX_READERS = UINT_MAX;
 35 | 
 36 |  public:
 37 |   ReaderWriterLatch() = default;
 38 |   ~ReaderWriterLatch() { std::lock_guard<mutex_t> guard(mutex_); }
 39 | 
 40 |   DISALLOW_COPY(ReaderWriterLatch);
 41 | 
 42 |   /**
 43 |    * Acquire a write latch.
 44 |    */
 45 |   void WLock() {
 46 |     std::unique_lock<mutex_t> latch(mutex_);
 47 |     while (writer_entered_) {
 48 |       reader_.wait(latch);
 49 |     }
 50 |     writer_entered_ = true;
 51 |     while (reader_count_ > 0) {
 52 |       writer_.wait(latch);
 53 |     }
 54 |   }
 55 | 
 56 |   /**
 57 |    * Release a write latch.
 58 |    */
 59 |   void WUnlock() {
 60 |     std::lock_guard<mutex_t> guard(mutex_);
 61 |     writer_entered_ = false;
 62 |     reader_.notify_all();
 63 |   }
 64 | 
 65 |   /**
 66 |    * Acquire a read latch.
 67 |    */
 68 |   void RLock() {
 69 |     std::unique_lock<mutex_t> latch(mutex_);
 70 |     while (writer_entered_ || reader_count_ == MAX_READERS) {
 71 |       reader_.wait(latch);
 72 |     }
 73 |     reader_count_++;
 74 |   }
 75 | 
 76 |   /**
 77 |    * Release a read latch.
 78 |    */
 79 |   void RUnlock() {
 80 |     std::lock_guard<mutex_t> guard(mutex_);
 81 |     reader_count_--;
 82 |     if (writer_entered_) {
 83 |       if (reader_count_ == 0) {
 84 |         writer_.notify_one();
 85 |       }
 86 |     } else {
 87 |       if (reader_count_ == MAX_READERS - 1) {
 88 |         reader_.notify_one();
 89 |       }
 90 |     }
 91 |   }
 92 | 
 93 |  private:
 94 |   mutex_t mutex_;
 95 |   cond_t writer_;
 96 |   cond_t reader_;
 97 |   uint32_t reader_count_{0};
 98 |   bool writer_entered_{false};
 99 | };
100 | 
101 | }  // namespace bustub
102 | 


--------------------------------------------------------------------------------
/examples/cluster.conf:
--------------------------------------------------------------------------------
 1 | protocol: "tcp"
 2 | replicas: {
 3 |     addresses: "192.168.2.11",
 4 |     addresses: "192.168.2.12",
 5 | }
 6 | replicas: {
 7 |     addresses: "192.168.2.13",
 8 |     addresses: "192.168.2.14",
 9 | }
10 | broker_ports: 2021
11 | server_port: 2023
12 | forwarder_port: 2024
13 | sequencer_port: 2025
14 | num_partitions: 2
15 | num_workers: 3
16 | mh_orderer_batch_duration: 5
17 | sequencer_batch_duration: 5
18 | simple_partitioning {
19 |     num_records: 1000
20 |     record_size_bytes: 10
21 | }
22 | sample_rate: 10
23 | 


--------------------------------------------------------------------------------
/examples/copy.json:
--------------------------------------------------------------------------------
1 | {
2 |   "read_set": ["0", "1", "2"],
3 |   "write_set": ["3", "4", "5"],
4 |   "code": [
5 |     ["COPY", "0", "3"],
6 |     ["COPY", "1", "4"],
7 |     ["COPY", "2", "5"]
8 |   ]
9 | }


--------------------------------------------------------------------------------
/examples/read.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "read_set": ["0", "1", "2", "3", "4", "5"],
 3 |   "write_set": [],
 4 |   "code": [
 5 |     ["GET", "0"],
 6 |     ["GET", "1"],
 7 |     ["GET", "2"],
 8 |     ["GET", "3"],
 9 |     ["GET", "4"],
10 |     ["GET", "5"]
11 |   ]
12 | }


--------------------------------------------------------------------------------
/examples/single.conf:
--------------------------------------------------------------------------------
 1 | protocol: "tcp"
 2 | replicas: {
 3 |     addresses: "127.0.0.1"
 4 | }
 5 | broker_ports: 2021
 6 | server_port: 2023
 7 | sequencer_port: 2024
 8 | forwarder_port: 2025
 9 | num_partitions: 1
10 | num_workers: 3
11 | sequencer_batch_duration: 5
12 | simple_partitioning {
13 |     num_records: 1000
14 |     record_size_bytes: 10
15 | }
16 | sample_rate: 100


--------------------------------------------------------------------------------
/examples/sleep.json:
--------------------------------------------------------------------------------
1 | {
2 |   "read_set": ["0"],
3 |   "write_set": ["0"],
4 |   "code": [["SLEEP", "3"]]
5 | }


--------------------------------------------------------------------------------
/examples/write.json:
--------------------------------------------------------------------------------
1 | {
2 |   "read_set": [],
3 |   "write_set": ["0", "1", "2"],
4 |   "code": [
5 |     ["SET", "0", "Hello"],
6 |     ["SET", "1", "World"],
7 |     ["SET", "2", "!!!!!"]
8 |   ]
9 | }


--------------------------------------------------------------------------------
/execution/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | target_sources(slog-core
 2 |   PRIVATE
 3 |     execution.cpp
 4 |     execution.h
 5 |     key_value.cpp
 6 |     tpcc.cpp
 7 |     tpcc/constants.h
 8 |     tpcc/deliver.cpp
 9 |     tpcc/load_tables.cpp
10 |     tpcc/load_tables.h
11 |     tpcc/metadata_initializer.cpp
12 |     tpcc/metadata_initializer.h
13 |     tpcc/new_order.cpp
14 |     tpcc/order_status.cpp
15 |     tpcc/payment.cpp
16 |     tpcc/scalar.h
17 |     tpcc/stock_level.cpp
18 |     tpcc/storage_adapter.cpp
19 |     tpcc/storage_adapter.h
20 |     tpcc/table.h
21 |     tpcc/transaction.h
22 |     tpcc/types.h
23 | )


--------------------------------------------------------------------------------
/execution/execution.cpp:
--------------------------------------------------------------------------------
 1 | #include "execution/execution.h"
 2 | 
 3 | namespace slog {
 4 | 
 5 | void Execution::ApplyWrites(const Transaction& txn, const SharderPtr& sharder,
 6 |                             const std::shared_ptr<Storage>& storage) {
 7 |   for (const auto& kv : txn.keys()) {
 8 |     const auto& key = kv.key();
 9 |     const auto& value = kv.value_entry();
10 |     if (!sharder->is_local_key(key) || value.type() == KeyType::READ) {
11 |       continue;
12 |     }
13 |     Record new_record;
14 |     new_record.SetMetadata(value.metadata());
15 |     new_record.SetValue(value.new_value());
16 |     storage->Write(key, new_record);
17 |   }
18 |   for (const auto& key : txn.deleted_keys()) {
19 |     storage->Delete(key);
20 |   }
21 | }
22 | 
23 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/execution.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <unordered_map>
 4 | 
 5 | #include "common/sharder.h"
 6 | #include "execution/execution.h"
 7 | #include "proto/transaction.pb.h"
 8 | #include "storage/storage.h"
 9 | 
10 | namespace slog {
11 | 
12 | class Execution {
13 |  public:
14 |   virtual ~Execution() = default;
15 |   virtual void Execute(Transaction& txn) = 0;
16 | 
17 |   static void ApplyWrites(const Transaction& txn, const SharderPtr& sharder, const std::shared_ptr<Storage>& storage);
18 | };
19 | 
20 | class KeyValueExecution : public Execution {
21 |  public:
22 |   KeyValueExecution(const SharderPtr& sharder, const std::shared_ptr<Storage>& storage);
23 |   void Execute(Transaction& txn) final;
24 | 
25 |  private:
26 |   SharderPtr sharder_;
27 |   std::shared_ptr<Storage> storage_;
28 | };
29 | 
30 | class NoopExecution : public Execution {
31 |  public:
32 |   void Execute(Transaction& txn) final { txn.set_status(TransactionStatus::COMMITTED); }
33 | };
34 | 
35 | class TPCCExecution : public Execution {
36 |  public:
37 |   TPCCExecution(const SharderPtr& sharder, const std::shared_ptr<Storage>& storage);
38 |   void Execute(Transaction& txn) final;
39 | 
40 |  private:
41 |   SharderPtr sharder_;
42 |   std::shared_ptr<Storage> storage_;
43 | };
44 | 
45 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/key_value.cpp:
--------------------------------------------------------------------------------
 1 | #include <sstream>
 2 | #include <thread>
 3 | 
 4 | #include "execution/execution.h"
 5 | 
 6 | namespace slog {
 7 | 
 8 | KeyValueExecution::KeyValueExecution(const SharderPtr& sharder, const std::shared_ptr<Storage>& storage)
 9 |     : sharder_(sharder), storage_(storage) {}
10 | 
11 | void KeyValueExecution::Execute(Transaction& txn) {
12 |   bool aborted = false;
13 |   std::ostringstream abort_reason;
14 |   std::unordered_map<std::string, int> key_index;
15 |   for (int i = 0; i < txn.keys_size(); i++) {
16 |     key_index.emplace(txn.keys(i).key(), i);
17 |   }
18 | 
19 |   for (auto& p : txn.code().procedures()) {
20 |     const auto& args = p.args();
21 |     if (args.empty()) {
22 |       continue;
23 |     }
24 |     if (args[0] == "SET") {
25 |       auto it = key_index.find(args[1]);
26 |       if (it == key_index.end()) {
27 |         continue;
28 |       }
29 |       auto value = txn.mutable_keys(it->second)->mutable_value_entry();
30 |       if (value->type() != KeyType::WRITE) {
31 |         continue;
32 |       }
33 |       value->set_new_value(args[2]);
34 |     } else if (args[0] == "DEL") {
35 |       auto it = key_index.find(args[1]);
36 |       if (it != key_index.end() || txn.keys(it->second).value_entry().type() != KeyType::WRITE) {
37 |         continue;
38 |       }
39 |       txn.mutable_deleted_keys()->Add(std::string(args[1]));
40 |     } else if (args[0] == "COPY") {
41 |       auto src_it = key_index.find(args[1]);
42 |       auto dst_it = key_index.find(args[2]);
43 |       if (src_it == key_index.end() || dst_it == key_index.end()) {
44 |         continue;
45 |       }
46 |       const auto& src_value = txn.keys(src_it->second).value_entry();
47 |       auto dst_value = txn.mutable_keys(dst_it->second)->mutable_value_entry();
48 |       if (dst_value->type() != KeyType::WRITE) {
49 |         continue;
50 |       }
51 |       dst_value->set_new_value(src_value.value());
52 |     } else if (args[0] == "EQ") {
53 |       auto it = key_index.find(args[1]);
54 |       if (it == key_index.end()) {
55 |         continue;
56 |       }
57 |       const auto& value = txn.keys(it->second).value_entry().value();
58 |       if (value != args[2]) {
59 |         aborted = true;
60 |         abort_reason << "Key = " << args[1] << ". Expected value = " << args[2] << ". Actual value = " << value;
61 |       }
62 |     } else if (args[0] == "SLEEP") {
63 |       std::this_thread::sleep_for(std::chrono::milliseconds(std::stoi(args[1])));
64 |     }
65 |   }
66 | 
67 |   if (aborted) {
68 |     txn.set_status(TransactionStatus::ABORTED);
69 |     txn.set_abort_reason(abort_reason.str());
70 |   } else {
71 |     txn.set_status(TransactionStatus::COMMITTED);
72 |     ApplyWrites(txn, sharder_, storage_);
73 |   }
74 | }
75 | 
76 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/tpcc/constants.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | namespace slog {
 4 | namespace tpcc {
 5 | 
 6 | const int kMaxItems = 100000;
 7 | const int kDistPerWare = 10;
 8 | const int kCustPerDist = 3000;
 9 | const int kOrdPerDist = 3000;
10 | const int kLinePerOrder = 10;
11 | 
12 | }  // namespace tpcc
13 | }  // namespace slog
14 | 


--------------------------------------------------------------------------------
/execution/tpcc/deliver.cpp:
--------------------------------------------------------------------------------
 1 | #include "execution/tpcc/transaction.h"
 2 | 
 3 | namespace slog {
 4 | namespace tpcc {
 5 | 
 6 | DeliverTxn::DeliverTxn(const StorageAdapterPtr& storage_adapter, int w_id, int d_id, int no_o_id, int c_id,
 7 |                        int o_carrier, int64_t datetime)
 8 |     : customer_(storage_adapter), new_order_(storage_adapter), order_(storage_adapter), order_line_(storage_adapter) {
 9 |   a_w_id_ = MakeInt32Scalar(w_id);
10 |   a_d_id_ = MakeInt8Scalar(d_id);
11 |   a_no_o_id_ = MakeInt32Scalar(no_o_id);
12 |   a_c_id_ = MakeInt32Scalar(c_id);
13 |   a_o_carrier_ = MakeInt8Scalar(o_carrier);
14 |   datetime_ = MakeInt64Scalar(datetime);
15 | }
16 | 
17 | bool DeliverTxn::Read() {
18 |   order_.Select({a_w_id_, a_d_id_, a_no_o_id_}, {OrderSchema::Column::C_ID});
19 | 
20 |   auto ol_id = MakeInt8Scalar();
21 |   for (int i = 1; i <= kLinePerOrder; i++) {
22 |     ol_id->value = i;
23 |     auto res = order_line_.Select({a_w_id_, a_d_id_, a_no_o_id_, ol_id}, {OrderLineSchema::Column::AMOUNT});
24 |     if (!res.empty()) {
25 |       sum_o_amount_->value += UncheckedCast<Int32Scalar>(res[0])->value;
26 |     }
27 |   }
28 |   auto res = customer_.Select({a_w_id_, a_d_id_, a_c_id_},
29 |                               {CustomerSchema::Column::BALANCE, CustomerSchema::Column::DELIVERY_CNT});
30 |   if (!res.empty()) {
31 |     c_balance_ = UncheckedCast<Int64Scalar>(res[0]);
32 |     c_delivery_cnt_ = UncheckedCast<Int16Scalar>(res[1]);
33 |   }
34 | 
35 |   return true;
36 | }
37 | 
38 | void DeliverTxn::Compute() {
39 |   new_c_balance_->value = c_balance_->value + sum_o_amount_->value;
40 |   new_c_delivery_cnt_->value = c_delivery_cnt_->value + 1;
41 | }
42 | 
43 | bool DeliverTxn::Write() {
44 |   new_order_.Delete({a_w_id_, a_d_id_, a_no_o_id_});
45 |   order_.Update({a_w_id_, a_d_id_, a_no_o_id_}, {OrderSchema::Column::CARRIER_ID}, {a_o_carrier_});
46 |   auto ol_id = MakeInt8Scalar();
47 |   for (int i = 1; i <= kLinePerOrder; i++) {
48 |     ol_id->value = i;
49 |     order_line_.Update({a_w_id_, a_d_id_, a_no_o_id_, ol_id}, {OrderLineSchema::Column::DELIVERY_D}, {datetime_});
50 |   }
51 |   customer_.Update({a_w_id_, a_d_id_, a_c_id_}, {CustomerSchema::Column::BALANCE, CustomerSchema::Column::DELIVERY_CNT},
52 |                    {new_c_balance_, new_c_delivery_cnt_});
53 |   return true;
54 | }
55 | 
56 | }  // namespace tpcc
57 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/tpcc/load_tables.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "execution/tpcc/constants.h"
 4 | #include "execution/tpcc/storage_adapter.h"
 5 | 
 6 | namespace slog {
 7 | namespace tpcc {
 8 | 
 9 | void LoadTables(const StorageAdapterPtr& storage_adapter, int W, int num_replicas, int num_partitions, int partition,
10 |                 int num_threads = 3);
11 | 
12 | }  // namespace tpcc
13 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/tpcc/metadata_initializer.cpp:
--------------------------------------------------------------------------------
 1 | #include "execution/tpcc/metadata_initializer.h"
 2 | 
 3 | #include <glog/logging.h>
 4 | 
 5 | namespace slog {
 6 | namespace tpcc {
 7 | 
 8 | TPCCMetadataInitializer::TPCCMetadataInitializer(uint32_t num_replicas, uint32_t num_partitions)
 9 |     : num_replicas_(num_replicas), num_partitions_(num_partitions) {}
10 | 
11 | Metadata TPCCMetadataInitializer::Compute(const Key& key) {
12 |   CHECK_GE(key.size(), 4) << "Invalid key";
13 |   uint32_t warehouse_id = *reinterpret_cast<const uint32_t*>(key.data());
14 |   return Metadata(((warehouse_id - 1) / num_partitions_) % num_replicas_);
15 | }
16 | 
17 | }  // namespace tpcc
18 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/tpcc/metadata_initializer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "storage/metadata_initializer.h"
 4 | 
 5 | namespace slog {
 6 | namespace tpcc {
 7 | 
 8 | class TPCCMetadataInitializer : public MetadataInitializer {
 9 |  public:
10 |   TPCCMetadataInitializer(uint32_t num_replicas, uint32_t num_partitions);
11 |   virtual Metadata Compute(const Key& key);
12 | 
13 |  private:
14 |   uint32_t num_replicas_;
15 |   uint32_t num_partitions_;
16 | };
17 | 
18 | }  // namespace tpcc
19 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/tpcc/order_status.cpp:
--------------------------------------------------------------------------------
 1 | #include "execution/tpcc/transaction.h"
 2 | 
 3 | namespace slog {
 4 | namespace tpcc {
 5 | 
 6 | OrderStatusTxn::OrderStatusTxn(const StorageAdapterPtr& storage_adapter, int w_id, int d_id, int c_id, int o_id)
 7 |     : customer_(storage_adapter), order_(storage_adapter), order_line_(storage_adapter) {
 8 |   a_w_id_ = MakeInt32Scalar(w_id);
 9 |   a_d_id_ = MakeInt8Scalar(d_id);
10 |   a_c_id_ = MakeInt32Scalar(c_id);
11 |   a_o_id_ = MakeInt32Scalar(o_id);
12 | }
13 | 
14 | bool OrderStatusTxn::Read() {
15 |   customer_.Select({a_w_id_, a_d_id_, a_c_id_}, {CustomerSchema::Column::FULL_NAME, CustomerSchema::Column::BALANCE});
16 |   order_.Select({a_w_id_, a_d_id_, a_o_id_}, {OrderSchema::Column::ENTRY_D, OrderSchema::Column::CARRIER_ID});
17 |   auto ol_number = MakeInt8Scalar();
18 |   for (int i = 1; i <= kLinePerOrder; i++) {
19 |     ol_number->value = i;
20 |     order_line_.Select(
21 |         {a_w_id_, a_d_id_, a_o_id_, ol_number},
22 |         {OrderLineSchema::Column::I_ID, OrderLineSchema::Column::SUPPLY_W_ID, OrderLineSchema::Column::QUANTITY,
23 |          OrderLineSchema::Column::AMOUNT, OrderLineSchema::Column::DELIVERY_D});
24 |   }
25 | 
26 |   return true;
27 | }
28 | 
29 | }  // namespace tpcc
30 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/tpcc/stock_level.cpp:
--------------------------------------------------------------------------------
 1 | #include "execution/tpcc/transaction.h"
 2 | 
 3 | namespace slog {
 4 | namespace tpcc {
 5 | 
 6 | StockLevelTxn::StockLevelTxn(const StorageAdapterPtr& storage_adapter, int w_id, int d_id, int o_id,
 7 |                              const std::array<int, kTotalItems>& i_ids)
 8 |     : district_(storage_adapter), order_line_(storage_adapter), stock_(storage_adapter) {
 9 |   a_w_id_ = MakeInt32Scalar(w_id);
10 |   a_d_id_ = MakeInt8Scalar(d_id);
11 |   a_o_id_ = MakeInt32Scalar(o_id);
12 |   for (int i = 0; i < kTotalItems; i++) {
13 |     a_i_ids_[i] = MakeInt32Scalar(i_ids[i]);
14 |   }
15 | }
16 | 
17 | bool StockLevelTxn::Read() {
18 |   district_.Select({a_w_id_, a_d_id_}, {DistrictSchema::Column::NEXT_O_ID});
19 |   auto o_id = MakeInt32Scalar();
20 |   auto ol_number = MakeInt8Scalar();
21 |   for (int i = a_o_id_->value - 20; i < a_o_id_->value; i++) {
22 |     o_id->value = i;
23 |     for (int j = 0; j < kLinePerOrder; j++) {
24 |       ol_number->value = j;
25 |       order_line_.Select({a_w_id_, a_d_id_, o_id, ol_number}, {OrderLineSchema::Column::I_ID});
26 |     }
27 |   }
28 |   for (int i = 0; i < kTotalItems; i++) {
29 |     stock_.Select({a_w_id_, a_i_ids_[i]}, {StockSchema::Column::QUANTITY});
30 |   }
31 |   return true;
32 | }
33 | 
34 | }  // namespace tpcc
35 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/tpcc/storage_adapter.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "common/types.h"
 4 | #include "proto/transaction.pb.h"
 5 | #include "storage/metadata_initializer.h"
 6 | #include "storage/storage.h"
 7 | 
 8 | namespace slog {
 9 | namespace tpcc {
10 | 
11 | class StorageAdapter {
12 |  public:
13 |   virtual ~StorageAdapter() = default;
14 |   virtual const std::string* Read(const std::string& key) = 0;
15 |   // Returns true if insertion succeeds
16 |   virtual bool Insert(const std::string& key, std::string&& value) = 0;
17 |   // Returns true if key exists before updating
18 |   virtual bool Update(const std::string& key, std::function<void(std::string&)>&& update_fn) = 0;
19 |   virtual bool Delete(std::string&& key) = 0;
20 | };
21 | 
22 | using StorageAdapterPtr = std::shared_ptr<StorageAdapter>;
23 | 
24 | class KVStorageAdapter : public StorageAdapter {
25 |  public:
26 |   KVStorageAdapter(const std::shared_ptr<Storage>& storage,
27 |                    const std::shared_ptr<MetadataInitializer>& metadata_initializer);
28 |   // This Read method is leaky. Only used for testing
29 |   const std::string* Read(const std::string&) override;
30 |   bool Insert(const std::string& key, std::string&& value) override;
31 |   bool Update(const std::string&, std::function<void(std::string&)>&&) override {
32 |     throw std::runtime_error("Update is unimplemented in KVStorageAdapter");
33 |   }
34 |   bool Delete(std::string&&) override { throw std::runtime_error("Delete is unimplemented in KVStorageAdapter"); }
35 | 
36 |  private:
37 |   std::shared_ptr<Storage> storage_;
38 |   std::shared_ptr<MetadataInitializer> metadata_initializer_;
39 |   std::vector<std::string> buffer_;
40 | };
41 | 
42 | class TxnStorageAdapter : public StorageAdapter {
43 |  public:
44 |   TxnStorageAdapter(Transaction& txn);
45 |   const std::string* Read(const std::string& key) override;
46 |   bool Insert(const std::string& key, std::string&& value) override;
47 |   bool Update(const std::string& key, std::function<void(std::string&)>&& update_fn) override;
48 |   bool Delete(std::string&& key) override;
49 | 
50 |  private:
51 |   void CheckIndexSize();
52 |   Transaction& txn_;
53 |   std::unordered_map<std::string, int> key_index_;
54 | };
55 | 
56 | class TxnKeyGenStorageAdapter : public StorageAdapter {
57 |  public:
58 |   TxnKeyGenStorageAdapter(Transaction& txn);
59 | 
60 |   const std::string* Read(const std::string& key) override;
61 |   bool Insert(const std::string& key, std::string&& value) override;
62 |   bool Update(const std::string& key, std::function<void(std::string&)>&& update_fn) override;
63 |   bool Delete(std::string&& key) override;
64 | 
65 |   void Finialize();
66 | 
67 |  private:
68 |   void NewReadKey(const std::string& key);
69 |   void NewWriteKey(const std::string& key);
70 |   Transaction& txn_;
71 |   std::unordered_map<std::string, KeyType> key_index_;
72 |   bool finalized_;
73 | };
74 | 
75 | }  // namespace tpcc
76 | }  // namespace slog


--------------------------------------------------------------------------------
/execution/tpcc/types.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | 
 5 | namespace slog {
 6 | namespace tpcc {
 7 | 
 8 | enum class DataTypeName { INT8, INT16, INT32, INT64, FIXED_TEXT };
 9 | 
10 | class DataType {
11 |  public:
12 |   DataType() = default;
13 |   virtual ~DataType() = default;
14 |   virtual DataTypeName name() const = 0;
15 |   virtual std::size_t size() const = 0;
16 |   virtual std::string to_string() const = 0;
17 | };
18 | 
19 | template <typename BaseType>
20 | class NumericDataType : public DataType {
21 |  public:
22 |   using CType = BaseType;
23 |   std::size_t size() const override { return sizeof(BaseType); }
24 | };
25 | 
26 | #define STRINGIFY(S) #S
27 | #define NUMERIC_TYPE(KLASS, NAME, CTYPE)                               \
28 |   class KLASS : public NumericDataType<CTYPE> {                        \
29 |    public:                                                             \
30 |     DataTypeName name() const override { return DataTypeName::NAME; }  \
31 |     std::string to_string() const override { return STRINGIFY(NAME); } \
32 |     inline static std::shared_ptr<DataType> Get() {                    \
33 |       static auto result = std::make_shared<KLASS>();                  \
34 |       return result;                                                   \
35 |     }                                                                  \
36 |   }
37 | 
38 | NUMERIC_TYPE(Int8Type, INT8, int8_t);
39 | NUMERIC_TYPE(Int16Type, INT16, int16_t);
40 | NUMERIC_TYPE(Int32Type, INT32, int32_t);
41 | NUMERIC_TYPE(Int64Type, INT64, int64_t);
42 | 
43 | template <size_t Width>
44 | class FixedTextType : public DataType {
45 |  public:
46 |   DataTypeName name() const override { return DataTypeName::FIXED_TEXT; }
47 |   std::string to_string() const override { return "FIXED_TEXT<" + std::to_string(Width) + ">"; }
48 |   size_t size() const override { return Width; }
49 | 
50 |   inline static std::shared_ptr<DataType> Get() {
51 |     static auto result = std::make_shared<FixedTextType<Width>>();
52 |     return result;
53 |   }
54 | };
55 | 
56 | inline bool operator==(const DataType& dt1, const DataType& dt2) {
57 |   if (dt1.name() != dt2.name()) {
58 |     return false;
59 |   }
60 |   if (dt1.name() == DataTypeName::FIXED_TEXT && dt1.size() != dt2.size()) {
61 |     return false;
62 |   }
63 |   return true;
64 | }
65 | 
66 | }  // namespace tpcc
67 | }  // namespace slog


--------------------------------------------------------------------------------
/module/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | target_sources(slog-core
 2 |   PRIVATE
 3 |     base/module.cpp
 4 |     base/module.h
 5 |     base/networked_module.cpp
 6 |     base/networked_module.h
 7 |     consensus.cpp
 8 |     consensus.h
 9 |     forwarder.cpp
10 |     forwarder.h
11 |     interleaver.cpp
12 |     interleaver.h
13 |     multi_home_orderer.cpp
14 |     multi_home_orderer.h
15 |     scheduler.cpp
16 |     scheduler.h
17 |     scheduler_components/ddr_lock_manager.cpp
18 |     scheduler_components/ddr_lock_manager.h
19 |     scheduler_components/old_lock_manager.cpp
20 |     scheduler_components/old_lock_manager.h
21 |     scheduler_components/per_key_remaster_manager.cpp
22 |     scheduler_components/per_key_remaster_manager.h
23 |     scheduler_components/remaster_manager.h
24 |     scheduler_components/rma_lock_manager.cpp
25 |     scheduler_components/rma_lock_manager.h
26 |     scheduler_components/simple_remaster_manager.cpp
27 |     scheduler_components/simple_remaster_manager.h
28 |     scheduler_components/txn_holder.cpp
29 |     scheduler_components/txn_holder.h
30 |     scheduler_components/worker.cpp
31 |     scheduler_components/worker.h
32 |     sequencer.cpp
33 |     sequencer.h
34 |     server.cpp
35 |     server.h
36 |     txn_generator.cpp
37 |     txn_generator.h)
38 | 


--------------------------------------------------------------------------------
/module/base/module.cpp:
--------------------------------------------------------------------------------
 1 | #include "module/base/module.h"
 2 | 
 3 | #include <glog/logging.h>
 4 | 
 5 | #include "common/constants.h"
 6 | #include "common/thread_utils.h"
 7 | 
 8 | using std::shared_ptr;
 9 | using std::unique_ptr;
10 | 
11 | namespace slog {
12 | 
13 | ModuleRunner::ModuleRunner(const shared_ptr<Module>& module) : module_(module), running_(false), setup_(false) {}
14 | 
15 | ModuleRunner::~ModuleRunner() {
16 |   running_ = false;
17 |   if (thread_.joinable()) {
18 |     thread_.join();
19 |     LOG(INFO) << module_->name() << " - thread stopped";
20 |   }
21 | }
22 | 
23 | void ModuleRunner::Start(std::optional<uint32_t> cpu) {
24 |   if (running_) {
25 |     throw std::runtime_error("The module has already started");
26 |   }
27 |   running_ = true;
28 |   if (cpu.has_value()) {
29 |     PinToCpu(pthread_self(), cpu.value());
30 |     LOG(INFO) << module_->name() << " - pinned to CPU " << cpu.value();
31 |   }
32 |   Run();
33 | }
34 | 
35 | void ModuleRunner::StartInNewThread(std::optional<uint32_t> cpu) {
36 |   if (running_) {
37 |     throw std::runtime_error("The module has already started");
38 |   }
39 |   running_ = true;
40 |   thread_ = std::thread(&ModuleRunner::Run, this);
41 |   SetThreadName(thread_.native_handle(), module_->name().c_str());
42 |   if (cpu.has_value()) {
43 |     PinToCpu(thread_.native_handle(), cpu.value());
44 |     LOG(INFO) << module_->name() << " - pinned to CPU " << cpu.value();
45 |   }
46 | }
47 | 
48 | void ModuleRunner::Run() {
49 |   if (!setup_) {
50 |     module_->SetUp();
51 |     setup_ = true;
52 |   }
53 |   while (running_) {
54 |     if (module_->Loop()) Stop();
55 |   }
56 | }
57 | 
58 | void ModuleRunner::Stop() { running_ = false; }
59 | 
60 | }  // namespace slog


--------------------------------------------------------------------------------
/module/base/module.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <atomic>
 4 | #include <optional>
 5 | #include <thread>
 6 | #include <vector>
 7 | 
 8 | namespace slog {
 9 | 
10 | /**
11 |  * An interface for a module in SLOG. Most modules are extended from NetworkedModule
12 |  * instead of directly from this class. A module only contains the instructions for
13 |  * what to run. It has to be coupled with a ModuleRunner to be able to run.
14 |  */
15 | class Module {
16 |  public:
17 |   Module() = default;
18 |   Module(const Module&) = delete;
19 |   const Module& operator=(const Module&) = delete;
20 |   virtual ~Module() {}
21 | 
22 |   /**
23 |    * To be called before the main loop. This gives a chance to perform
24 |    * all neccessary one-time initialization.
25 |    */
26 |   virtual void SetUp(){};
27 | 
28 |   /**
29 |    * Contains the actions to be perform in one iteration of the main loop.
30 |    * If this method returns true, the loop will stop.
31 |    */
32 |   virtual bool Loop() = 0;
33 | 
34 |   /**
35 |    * Module name
36 |    */
37 |   virtual std::string name() const = 0;
38 | };
39 | 
40 | /**
41 |  * A ModuleRunner executes a Module. Its execution can either live in
42 |  * a new thread or in the same thread as its caller.
43 |  */
44 | class ModuleRunner {
45 |  public:
46 |   ModuleRunner(const std::shared_ptr<Module>& module);
47 |   ~ModuleRunner();
48 | 
49 |   void Start(std::optional<uint32_t> cpu = {});
50 |   void StartInNewThread(std::optional<uint32_t> cpu = {});
51 | 
52 |   void Stop();
53 | 
54 |   std::shared_ptr<Module> module() { return module_; }
55 |   bool is_running() const { return running_; }
56 |   bool set_up() const { return setup_; }
57 | 
58 |  private:
59 |   void Run();
60 | 
61 |   std::shared_ptr<Module> module_;
62 |   std::thread thread_;
63 |   std::atomic<bool> running_;
64 |   std::atomic<bool> setup_;
65 | };
66 | 
67 | /**
68 |  * Helper function for creating a ModuleRunner.
69 |  */
70 | template <typename T, typename... Args>
71 | inline std::unique_ptr<ModuleRunner> MakeRunnerFor(Args&&... args) {
72 |   return std::make_unique<ModuleRunner>(std::make_shared<T>(std::forward<Args>(args)...));
73 | }
74 | 
75 | }  // namespace slog


--------------------------------------------------------------------------------
/module/base/networked_module.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <zmq.hpp>
 5 | 
 6 | #include "common/constants.h"
 7 | #include "common/metrics.h"
 8 | #include "common/types.h"
 9 | #include "connection/broker.h"
10 | #include "connection/poller.h"
11 | #include "connection/sender.h"
12 | #include "connection/zmq_utils.h"
13 | #include "module/base/module.h"
14 | #include "proto/internal.pb.h"
15 | 
16 | namespace slog {
17 | 
18 | struct ChannelOption {
19 |   ChannelOption(Channel channel, bool recv_raw = true) : channel(channel), recv_raw(recv_raw) {}
20 |   Channel channel;
21 |   bool recv_raw;
22 | };
23 | 
24 | /**
25 |  * Base class for modules that can send and receive in internal messages.
26 |  */
27 | class NetworkedModule : public Module {
28 |  public:
29 |   NetworkedModule(const std::shared_ptr<zmq::context_t>& context, const ConfigurationPtr& config, Channel channel,
30 |                   const MetricsRepositoryManagerPtr& metrics_manager,
31 |                   std::optional<std::chrono::milliseconds> poll_timeout, bool is_long_sender);
32 | 
33 |   NetworkedModule(const std::shared_ptr<Broker>& broker, ChannelOption chopt,
34 |                   const MetricsRepositoryManagerPtr& metrics_manager,
35 |                   std::optional<std::chrono::milliseconds> poll_timeout, bool is_long_sender = false);
36 | 
37 |   NetworkedModule(const std::shared_ptr<zmq::context_t>& context, const ConfigurationPtr& config, uint32_t port,
38 |                   Channel channel, const MetricsRepositoryManagerPtr& metrics_manager,
39 |                   std::optional<std::chrono::milliseconds> poll_timeout, bool is_long_sender = false);
40 | 
41 |  protected:
42 |   virtual void Initialize(){};
43 | 
44 |   virtual void OnInternalRequestReceived(EnvelopePtr&& env) = 0;
45 | 
46 |   virtual void OnInternalResponseReceived(EnvelopePtr&& /* env */) {}
47 | 
48 |   // Returns true if useful work was done
49 |   virtual bool OnCustomSocket() { return false; }
50 | 
51 |   void AddCustomSocket(zmq::socket_t&& new_socket);
52 |   zmq::socket_t& GetCustomSocket(size_t i);
53 | 
54 |   inline static EnvelopePtr NewEnvelope() { return std::make_unique<internal::Envelope>(); }
55 |   void Send(const internal::Envelope& env, MachineId to_machine_id, Channel to_channel);
56 |   void Send(EnvelopePtr&& env, MachineId to_machine_id, Channel to_channel);
57 |   void Send(EnvelopePtr&& env, Channel to_channel);
58 |   void Send(const internal::Envelope& env, const std::vector<MachineId>& to_machine_ids, Channel to_channel);
59 |   void Send(EnvelopePtr&& env, const std::vector<MachineId>& to_machine_ids, Channel to_channel);
60 | 
61 |   void NewTimedCallback(std::chrono::microseconds timeout, std::function<void()>&& cb);
62 | 
63 |   const std::shared_ptr<zmq::context_t>& context() const { return context_; }
64 |   const ConfigurationPtr& config() const { return config_; }
65 | 
66 |   Channel channel() const { return channel_; }
67 |   MetricsRepositoryManager& metrics_manager() { return *metrics_manager_; }
68 | 
69 |  private:
70 |   void SetUp() final;
71 |   bool Loop() final;
72 | 
73 |   bool OnEnvelopeReceived(EnvelopePtr&& wrapped_env);
74 | 
75 |   std::shared_ptr<zmq::context_t> context_;
76 |   ConfigurationPtr config_;
77 |   Channel channel_;
78 |   std::optional<uint32_t> port_;
79 |   MetricsRepositoryManagerPtr metrics_manager_;
80 |   zmq::socket_t inproc_socket_;
81 |   zmq::socket_t outproc_socket_;
82 |   std::vector<zmq::socket_t> custom_sockets_;
83 |   Sender sender_;
84 |   Poller poller_;
85 |   int recv_retries_start_;
86 |   int recv_retries_;
87 | 
88 |   std::string debug_info_;
89 | 
90 |   std::atomic<uint64_t> work_ = 0;
91 | };
92 | 
93 | }  // namespace slog


--------------------------------------------------------------------------------
/module/consensus.cpp:
--------------------------------------------------------------------------------
 1 | #include "module/consensus.h"
 2 | 
 3 | #include "common/proto_utils.h"
 4 | 
 5 | namespace slog {
 6 | 
 7 | using internal::Request;
 8 | 
 9 | namespace {
10 | 
11 | vector<MachineId> GetMembers(const ConfigurationPtr& config) {
12 |   auto local_rep = config->local_replica();
13 |   vector<MachineId> members;
14 |   members.reserve(config->num_partitions());
15 |   // Enlist all machines in the same region as members
16 |   for (uint32_t part = 0; part < config->num_partitions(); part++) {
17 |     members.push_back(config->MakeMachineId(local_rep, part));
18 |   }
19 |   return members;
20 | }
21 | 
22 | }  // namespace
23 | 
24 | GlobalPaxos::GlobalPaxos(const shared_ptr<Broker>& broker, std::chrono::milliseconds poll_timeout)
25 |     : SimulatedMultiPaxos(kGlobalPaxos, broker, GetMembers(broker->config()), broker->config()->local_machine_id(),
26 |                           poll_timeout),
27 |       local_machine_id_(broker->config()->local_machine_id()) {
28 |   auto& config = broker->config();
29 |   for (uint32_t rep = 0; rep < config->num_replicas(); rep++) {
30 |     multihome_orderers_.push_back(config->MakeMachineId(rep, config->leader_partition_for_multi_home_ordering()));
31 |   }
32 | }
33 | 
34 | void GlobalPaxos::OnCommit(uint32_t slot, uint32_t value, MachineId leader) {
35 |   if (local_machine_id_ != leader) {
36 |     return;
37 |   }
38 |   auto env = NewEnvelope();
39 |   auto order = env->mutable_request()->mutable_forward_batch_order()->mutable_remote_batch_order();
40 |   order->set_slot(slot);
41 |   order->set_batch_id(value);
42 |   Send(std::move(env), multihome_orderers_, kMultiHomeOrdererChannel);
43 | }
44 | 
45 | LocalPaxos::LocalPaxos(const shared_ptr<Broker>& broker, std::chrono::milliseconds poll_timeout)
46 |     : SimulatedMultiPaxos(kLocalPaxos, broker, GetMembers(broker->config()), broker->config()->local_machine_id(),
47 |                           poll_timeout) {}
48 | 
49 | void LocalPaxos::OnCommit(uint32_t slot, uint32_t value, MachineId leader) {
50 |   auto env = NewEnvelope();
51 |   auto order = env->mutable_request()->mutable_forward_batch_order()->mutable_local_batch_order();
52 |   order->set_queue_id(value);
53 |   order->set_slot(slot);
54 |   order->set_leader(leader);
55 |   Send(std::move(env), kLocalLogChannel);
56 | }
57 | 
58 | }  // namespace slog


--------------------------------------------------------------------------------
/module/consensus.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "paxos/simulated_multi_paxos.h"
 4 | 
 5 | namespace slog {
 6 | 
 7 | class GlobalPaxos : public SimulatedMultiPaxos {
 8 |  public:
 9 |   GlobalPaxos(const std::shared_ptr<Broker>& broker, std::chrono::milliseconds poll_timeout = kModuleTimeout);
10 | 
11 |  protected:
12 |   void OnCommit(uint32_t slot, uint32_t value, MachineId leader) final;
13 | 
14 |  private:
15 |   MachineId local_machine_id_;
16 |   vector<MachineId> multihome_orderers_;
17 | };
18 | 
19 | class LocalPaxos : public SimulatedMultiPaxos {
20 |  public:
21 |   LocalPaxos(const std::shared_ptr<Broker>& broker, std::chrono::milliseconds poll_timeout = kModuleTimeout);
22 | 
23 |  protected:
24 |   void OnCommit(uint32_t slot, uint32_t value, MachineId leader) final;
25 | };
26 | 
27 | }  // namespace slog


--------------------------------------------------------------------------------
/module/forwarder.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <random>
 4 | #include <unordered_map>
 5 | 
 6 | #include "common/configuration.h"
 7 | #include "common/metrics.h"
 8 | #include "common/sharder.h"
 9 | #include "common/types.h"
10 | #include "connection/broker.h"
11 | #include "module/base/networked_module.h"
12 | #include "proto/transaction.pb.h"
13 | #include "storage/lookup_master_index.h"
14 | #include "storage/metadata_initializer.h"
15 | 
16 | namespace slog {
17 | 
18 | /**
19 |  * A Forwarder determines the type of a transaction (single-home vs. multi-home)
20 |  * then forwards it to the appropriate module.
21 |  *
22 |  * To determine the type of a txn, it sends LookupMasterRequests to other Forwarder
23 |  * modules in the same region and aggregates the responses.
24 |  *
25 |  * INPUT:  ForwardTransaction and LookUpMasterRequest
26 |  *
27 |  * OUTPUT: If the txn is single-home, forward to the Sequencer in its home region.
28 |  *         If the txn is multi-home, forward to the MultiHomeOrderer for ordering;
29 |  *         if bypass_mh_orderer is set to true in the config, the multi-home txn is
30 |  *         sent directly to the involved regions.
31 |  *
32 |  *         For LookUpMasterRequest, a LookUpMasterResponse is sent back to
33 |  *         the requester.
34 |  */
35 | class Forwarder : public NetworkedModule {
36 |  public:
37 |   Forwarder(const std::shared_ptr<zmq::context_t>& context, const ConfigurationPtr& config,
38 |             const std::shared_ptr<LookupMasterIndex>& lookup_master_index,
39 |             const std::shared_ptr<MetadataInitializer>& metadata_initializer,
40 |             const MetricsRepositoryManagerPtr& metrics_manager,
41 |             std::chrono::milliseconds poll_timeout_ms = kModuleTimeout);
42 | 
43 |   std::string name() const override { return "Forwarder"; }
44 | 
45 |  protected:
46 |   void OnInternalRequestReceived(EnvelopePtr&& env) final;
47 |   void OnInternalResponseReceived(EnvelopePtr&& env) final;
48 | 
49 |  private:
50 |   void ProcessForwardTxn(EnvelopePtr&& env);
51 |   void ProcessLookUpMasterRequest(EnvelopePtr&& env);
52 |   void ProcessStatsRequest(const internal::StatsRequest& stats_request);
53 | 
54 |   void SendLookupMasterRequestBatch();
55 | 
56 |   /**
57 |    * Pre-condition: transaction type is not UNKNOWN
58 |    */
59 |   void Forward(EnvelopePtr&& env);
60 | 
61 |   const SharderPtr sharder_;
62 |   std::shared_ptr<LookupMasterIndex> lookup_master_index_;
63 |   std::shared_ptr<MetadataInitializer> metadata_initializer_;
64 |   std::unordered_map<TxnId, EnvelopePtr> pending_transactions_;
65 |   std::vector<internal::Envelope> partitioned_lookup_request_;
66 |   int batch_size_;
67 | 
68 |   std::mt19937 rg_;
69 | 
70 |   bool collecting_stats_;
71 |   std::chrono::steady_clock::time_point batch_starting_time_;
72 |   std::vector<int> stat_batch_sizes_;
73 |   std::vector<float> stat_batch_durations_ms_;
74 | };
75 | 
76 | }  // namespace slog


--------------------------------------------------------------------------------
/module/interleaver.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <queue>
 4 | #include <unordered_map>
 5 | 
 6 | #include "common/configuration.h"
 7 | #include "common/metrics.h"
 8 | #include "common/types.h"
 9 | #include "data_structure/batch_log.h"
10 | #include "module/base/networked_module.h"
11 | #include "proto/transaction.pb.h"
12 | 
13 | namespace slog {
14 | 
15 | /**
16 |  * A LocalLog buffers batch data from local partitions and outputs
17 |  * the next local batch in the order given by the local Paxos process
18 |  */
19 | class LocalLog {
20 |  public:
21 |   void AddBatchId(uint32_t queue_id, uint32_t position, BatchId batch_id);
22 |   void AddSlot(SlotId slot_id, uint32_t queue_id, MachineId leader);
23 | 
24 |   bool HasNextBatch() const;
25 |   std::pair<SlotId, std::pair<BatchId, MachineId>> NextBatch();
26 | 
27 |   /* For debugging */
28 |   size_t NumBufferedSlots() const { return slots_.NumBufferredItems(); }
29 | 
30 |   /* For debugging */
31 |   std::unordered_map<uint32_t, size_t> NumBufferedBatchesPerQueue() const {
32 |     std::unordered_map<uint32_t, size_t> queue_sizes;
33 |     for (const auto& [part, log] : batch_queues_) {
34 |       queue_sizes.insert_or_assign(part, log.NumBufferredItems());
35 |     }
36 |     return queue_sizes;
37 |   }
38 | 
39 |  private:
40 |   void UpdateReadyBatches();
41 | 
42 |   // Used to decide the next queue to choose a batch from
43 |   AsyncLog<std::pair<uint32_t, MachineId>> slots_;
44 |   // Batches from a partition form a queue
45 |   std::unordered_map<uint32_t, AsyncLog<BatchId>> batch_queues_;
46 |   // Chosen batches
47 |   std::queue<std::pair<SlotId, std::pair<BatchId, MachineId>>> ready_batches_;
48 | };
49 | 
50 | class Interleaver : public NetworkedModule {
51 |  public:
52 |   Interleaver(const std::shared_ptr<Broker>& broker, const MetricsRepositoryManagerPtr& metrics_manager,
53 |               std::chrono::milliseconds poll_timeout = kModuleTimeout);
54 | 
55 |   std::string name() const override { return "Interleaver"; }
56 | 
57 |  protected:
58 |   void Initialize() final;
59 |   bool OnCustomSocket() final;
60 |   void OnInternalRequestReceived(EnvelopePtr&& env) final;
61 | 
62 |  private:
63 |   void ProcessBatchReplicationAck(EnvelopePtr&& env);
64 |   void ProcessForwardBatchData(EnvelopePtr&& env);
65 |   void ProcessForwardBatchOrder(EnvelopePtr&& env);
66 |   void AdvanceLogs();
67 | 
68 |   void EmitBatch(BatchPtr&& batch);
69 | 
70 |   std::unordered_map<uint32_t, BatchLog> single_home_logs_;
71 |   LocalLog local_log_;
72 |   std::vector<MachineId> other_partitions_;
73 |   std::vector<bool> need_ack_from_replica_;
74 | };
75 | 
76 | }  // namespace slog


--------------------------------------------------------------------------------
/module/multi_home_orderer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "common/configuration.h"
 4 | #include "common/metrics.h"
 5 | #include "connection/broker.h"
 6 | #include "data_structure/batch_log.h"
 7 | #include "module/base/networked_module.h"
 8 | 
 9 | namespace slog {
10 | 
11 | /**
12 |  * A MultiHomeOrderer batches multi-home transactions and orders them globally
13 |  * with paxos.
14 |  *
15 |  * INPUT:  ForwardTxn or ForwardBatch
16 |  *
17 |  * OUTPUT: For ForwardTxn, it has to contains a MULTI_HOME txn, which is put
18 |  *         into a batch. The ID of this batch is sent to the global paxos
19 |  *         process for ordering, and simultaneously, this batch is sent to
20 |  *         the MultiHomeOrderer of all regions.
21 |  *
22 |  *         ForwardBatch'es are serialized into a log according to
23 |  *         their globally orderred IDs and then forwarded to the Sequencer.
24 |  */
25 | class MultiHomeOrderer : public NetworkedModule {
26 |  public:
27 |   MultiHomeOrderer(const std::shared_ptr<Broker>& broker, const MetricsRepositoryManagerPtr& metrics_manager,
28 |                    std::chrono::milliseconds poll_timeout = kModuleTimeout);
29 | 
30 |   std::string name() const override { return "MultiHomeOrderer"; }
31 | 
32 |  protected:
33 |   void OnInternalRequestReceived(EnvelopePtr&& env) final;
34 | 
35 |  private:
36 |   void ProcessForwardBatchData(EnvelopePtr&& env);
37 |   void ProcessForwardBatchOrder(EnvelopePtr&& env);
38 |   void ProcessStatsRequest(const internal::StatsRequest& stats_request);
39 |   void AdvanceLog();
40 | 
41 |   void NewBatch();
42 |   BatchId batch_id() const { return batch_id_counter_ * kMaxNumMachines + config()->local_machine_id(); }
43 |   void AddToBatch(Transaction* txn);
44 |   void SendBatch();
45 | 
46 |   std::vector<std::unique_ptr<internal::Batch>> batch_per_rep_;
47 |   BatchId batch_id_counter_;
48 |   int batch_size_;
49 | 
50 |   BatchLog multi_home_batch_log_;
51 | 
52 |   bool collecting_stats_;
53 |   std::chrono::steady_clock::time_point batch_starting_time_;
54 |   std::vector<int> stat_batch_sizes_;
55 |   std::vector<float> stat_batch_durations_ms_;
56 | };
57 | 
58 | }  // namespace slog


--------------------------------------------------------------------------------
/module/scheduler.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <glog/logging.h>
  4 | 
  5 | #include <unordered_map>
  6 | #include <unordered_set>
  7 | #include <vector>
  8 | 
  9 | #include "common/configuration.h"
 10 | #include "common/metrics.h"
 11 | #include "common/types.h"
 12 | #include "connection/broker.h"
 13 | #include "connection/sender.h"
 14 | #include "data_structure/batch_log.h"
 15 | #include "module/scheduler_components/txn_holder.h"
 16 | #include "module/scheduler_components/worker.h"
 17 | #include "storage/storage.h"
 18 | 
 19 | #if defined(REMASTER_PROTOCOL_SIMPLE)
 20 | #include "module/scheduler_components/simple_remaster_manager.h"
 21 | #if !defined(LOCK_MANAGER_OLD)
 22 | #error "SIMPLE remaster protocol is only compatible with OLD lock manager"
 23 | #endif
 24 | #elif defined(REMASTER_PROTOCOL_PER_KEY)
 25 | #include "module/scheduler_components/per_key_remaster_manager.h"
 26 | #if !defined(LOCK_MANAGER_OLD)
 27 | #error "PER_KEY remaster protocol is only compatible with OLD lock manager"
 28 | #endif
 29 | #elif defined(REMASTER_PROTOCOL_COUNTERLESS) && defined(LOCK_MANAGER_OLD)
 30 | #error "COUNTERLESS remaster protocol is not compatible with OLD lock manager"
 31 | #endif
 32 | 
 33 | #if defined(LOCK_MANAGER_OLD)
 34 | #include "module/scheduler_components/old_lock_manager.h"
 35 | #elif defined(LOCK_MANAGER_DDR)
 36 | #include "module/scheduler_components/ddr_lock_manager.h"
 37 | #else
 38 | #include "module/scheduler_components/rma_lock_manager.h"
 39 | #endif
 40 | 
 41 | namespace slog {
 42 | 
 43 | class Scheduler : public NetworkedModule {
 44 |  public:
 45 |   Scheduler(const std::shared_ptr<Broker>& broker, const std::shared_ptr<Storage>& storage,
 46 |             const MetricsRepositoryManagerPtr& metrics_manager,
 47 |             std::chrono::milliseconds poll_timeout = kModuleTimeout);
 48 | 
 49 |   std::string name() const override { return "Scheduler"; }
 50 | 
 51 |  protected:
 52 |   void Initialize() final;
 53 | 
 54 |   void OnInternalRequestReceived(EnvelopePtr&& env) final;
 55 | 
 56 |   // Handle responses from the workers
 57 |   bool OnCustomSocket() final;
 58 | 
 59 |  private:
 60 |   void ProcessTransaction(EnvelopePtr&& env);
 61 |   void ProcessStatsRequest(const internal::StatsRequest& stats_request);
 62 | 
 63 | #if defined(REMASTER_PROTOCOL_SIMPLE) || defined(REMASTER_PROTOCOL_PER_KEY)
 64 |   // Send single-home and lock-only transactions for counter checking
 65 |   void SendToRemasterManager(Transaction& txn);
 66 |   // Send transactions to lock manager or abort them
 67 |   void ProcessRemasterResult(RemasterOccurredResult result);
 68 | #endif
 69 | 
 70 |   // Send all transactions for locks
 71 |   void SendToLockManager(Transaction& txn);
 72 | 
 73 |   // Send txn to worker
 74 |   void Dispatch(TxnId txn_id, bool is_fast);
 75 | 
 76 |   /**
 77 |    * Aborts
 78 |    *
 79 |    * Once a transaction is sent to a worker, the worker will manage an abort.
 80 |    * If a remaster abort occurs at this partition or if a remote read abort
 81 |    * is received before the transaction is dispatched, then the abort is handled
 82 |    * here.
 83 |    *
 84 |    * Before the transaction data is erased, we wait to collect all lock-onlys of a multi-home txn
 85 |    */
 86 |   void TriggerPreDispatchAbort(TxnId txn_id);
 87 | 
 88 |   void MaybeCleanUpTxn(TxnId txn_id);
 89 | 
 90 | #if defined(REMASTER_PROTOCOL_SIMPLE)
 91 |   SimpleRemasterManager remaster_manager_;
 92 | #elif defined(REMASTER_PROTOCOL_PER_KEY)
 93 |   PerKeyRemasterManager remaster_manager_;
 94 | #endif
 95 | 
 96 | #if defined(REMASTER_PROTOCOL_SIMPLE) || defined(REMASTER_PROTOCOL_PER_KEY) || \
 97 |     (defined(LOCK_MANAGER_OLD) && !defined(REMASTER_PROTOCOL_COUNTERLESS))
 98 |   OldLockManager lock_manager_;
 99 | #elif defined(LOCK_MANAGER_DDR)
100 |   DDRLockManager lock_manager_;
101 | #else
102 |   RMALockManager lock_manager_;
103 | #endif
104 | 
105 |   std::unordered_map<TxnId, TxnHolder> active_txns_;
106 | 
107 |   // This must be defined at the end so that the workers exit before any resources
108 |   // in the scheduler is destroyed
109 |   std::vector<std::unique_ptr<ModuleRunner>> workers_;
110 | 
111 |   int64_t global_log_counter_;
112 | };
113 | 
114 | }  // namespace slog


--------------------------------------------------------------------------------
/module/scheduler_components/ddr_lock_manager.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | // Prevent mixing with other versions
  4 | #ifdef LOCK_MANAGER
  5 | #error "Only one lock manager can be included"
  6 | #endif
  7 | #define LOCK_MANAGER
  8 | 
  9 | #include <list>
 10 | #include <optional>
 11 | #include <unordered_map>
 12 | #include <unordered_set>
 13 | #include <vector>
 14 | 
 15 | #include "common/configuration.h"
 16 | #include "common/constants.h"
 17 | #include "common/json_utils.h"
 18 | #include "common/types.h"
 19 | #include "module/scheduler_components/txn_holder.h"
 20 | 
 21 | using std::list;
 22 | using std::optional;
 23 | using std::pair;
 24 | using std::shared_ptr;
 25 | using std::unordered_map;
 26 | using std::unordered_set;
 27 | using std::vector;
 28 | 
 29 | namespace slog {
 30 | 
 31 | /**
 32 |  * An object of this class represents the tail of the lock queue.
 33 |  * We don't update this structure when a transaction releases its
 34 |  * locks. Therefore, this structure might contain released transactions
 35 |  * so we need to verify any result returned from it.
 36 |  */
 37 | class LockQueueTail {
 38 |  public:
 39 |   optional<TxnId> AcquireReadLock(TxnId txn_id);
 40 |   vector<TxnId> AcquireWriteLock(TxnId txn_id);
 41 | 
 42 |   /* For debugging */
 43 |   optional<TxnId> write_lock_requester() const { return write_lock_requester_; }
 44 | 
 45 |   /* For debugging */
 46 |   vector<TxnId> read_lock_requesters() const { return read_lock_requesters_; }
 47 | 
 48 |  private:
 49 |   optional<TxnId> write_lock_requester_;
 50 |   vector<TxnId> read_lock_requesters_;
 51 | };
 52 | 
 53 | /**
 54 |  * This is a deterministic lock manager which grants locks for transactions
 55 |  * in the order that they request. If transaction X, appears before
 56 |  * transaction Y in the log, X always gets all locks before Y.
 57 |  *
 58 |  * DDR stands for Deterministic Deadlock Resolving. This lock manager is
 59 |  * remaster-aware like the RMA lock manager. However, for each lock wait
 60 |  * queue, it only keeps track of the tail of the queue. The dependencies
 61 |  * between the txns are tracked in a graph, which can be used to deterministically
 62 |  * detect and resolve deadlocks.
 63 |  *
 64 |  * Remastering:
 65 |  * Locks are taken on the tuple <key, replica>, using the transaction's
 66 |  * master metadata. The masters are checked in the worker, so if two
 67 |  * transactions hold separate locks for the same key, then one has an
 68 |  * incorrect master and will be aborted. Remaster transactions request the
 69 |  * locks for both <key, old replica> and <key, new replica>.
 70 |  */
 71 | class DDRLockManager {
 72 |  public:
 73 |   DDRLockManager();
 74 | 
 75 |   /**
 76 |    * Tries to acquire all locks for a given transaction. If not
 77 |    * all locks are acquired, the transaction is queued up to wait
 78 |    * for the current holders to release.
 79 |    *
 80 |    * @param txn The transaction whose locks are acquired.
 81 |    * @return    true if all locks are acquired, false if not and
 82 |    *            the transaction is queued up.
 83 |    */
 84 |   AcquireLocksResult AcquireLocks(const Transaction& txn);
 85 | 
 86 |   /**
 87 |    * Releases all locks that a transaction is holding or waiting for.
 88 |    *
 89 |    * @param txn_holder Holder of the transaction whose locks are released.
 90 |    *            LockOnly txn is not accepted.
 91 |    * @return    A set of IDs of transactions that are able to obtain
 92 |    *            all of their locks thanks to this release.
 93 |    */
 94 |   vector<TxnId> ReleaseLocks(TxnId txn_id);
 95 | 
 96 |   /**
 97 |    * Gets current statistics of the lock manager
 98 |    *
 99 |    * @param stats A JSON object where the statistics are stored into
100 |    */
101 |   void GetStats(rapidjson::Document& stats, uint32_t level) const;
102 | 
103 |  private:
104 |   struct TxnInfo {
105 |     TxnInfo(int unarrived) : unarrived_lock_requests(unarrived), waiting_for_cnt(0) {}
106 |     vector<TxnId> waited_by;
107 |     int unarrived_lock_requests;
108 |     int waiting_for_cnt;
109 | 
110 |     bool is_ready() const { return waiting_for_cnt == 0 && unarrived_lock_requests == 0; }
111 |   };
112 |   unordered_map<TxnId, TxnInfo> txn_info_;
113 |   unordered_map<KeyReplica, LockQueueTail> lock_table_;
114 | };
115 | 
116 | }  // namespace slog


--------------------------------------------------------------------------------
/module/scheduler_components/old_lock_manager.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #ifdef LOCK_MANAGER
  4 | #error "Only one lock manager can be included"
  5 | #endif
  6 | #define LOCK_MANAGER
  7 | 
  8 | #include <list>
  9 | #include <unordered_map>
 10 | #include <unordered_set>
 11 | #include <vector>
 12 | 
 13 | #include "common/configuration.h"
 14 | #include "common/constants.h"
 15 | #include "common/json_utils.h"
 16 | #include "common/types.h"
 17 | #include "module/scheduler_components/txn_holder.h"
 18 | 
 19 | using std::list;
 20 | using std::pair;
 21 | using std::shared_ptr;
 22 | using std::unordered_map;
 23 | using std::unordered_set;
 24 | using std::vector;
 25 | 
 26 | namespace slog {
 27 | 
 28 | /**
 29 |  * An object of this class represents the locking state of a key.
 30 |  * It contains the IDs of transactions that are holding and waiting
 31 |  * the lock and the mode of the lock.
 32 |  */
 33 | class OldLockState {
 34 |  public:
 35 |   bool AcquireReadLock(TxnId txn_id);
 36 |   bool AcquireWriteLock(TxnId txn_id);
 37 |   unordered_set<TxnId> Release(TxnId txn_id);
 38 |   bool Contains(TxnId txn_id);
 39 | 
 40 |   LockMode mode = LockMode::UNLOCKED;
 41 | 
 42 |   /* For debugging */
 43 |   const unordered_set<TxnId>& GetHolders() const { return holders_; }
 44 | 
 45 |   /* For debugging */
 46 |   const list<pair<TxnId, LockMode>>& GetWaiters() const { return waiter_queue_; }
 47 | 
 48 |  private:
 49 |   unordered_set<TxnId> holders_;
 50 |   unordered_set<TxnId> waiters_;
 51 |   list<pair<TxnId, LockMode>> waiter_queue_;
 52 | };
 53 | 
 54 | /**
 55 |  * This is a deterministic lock manager which grants locks for transactions
 56 |  * in the order that they request. If transaction X, appears before
 57 |  * transaction Y in the log, X always gets all locks before Y.
 58 |  */
 59 | class OldLockManager {
 60 |  public:
 61 |   /**
 62 |    * Tries to acquire all locks for a given transaction. If not
 63 |    * all locks are acquired, the transaction is queued up to wait
 64 |    * for the current holders to release.
 65 |    *
 66 |    * @param txn Transaction whose locks are acquired.
 67 |    * @return    true if all locks are acquired, false if not and
 68 |    *            the transaction is queued up.
 69 |    */
 70 |   AcquireLocksResult AcquireLocks(const Transaction& txn);
 71 | 
 72 |   /**
 73 |    * Releases all locks that a transaction is holding or waiting for.
 74 |    *
 75 |    * @param txn_id Id of transaction whose locks are released.
 76 |    *               LockOnly txn is not accepted.
 77 |    * @return    A set of IDs of transactions that are able to obtain
 78 |    *            all of their locks thanks to this release.
 79 |    */
 80 |   vector<TxnId> ReleaseLocks(TxnId txn_id);
 81 | 
 82 |   /**
 83 |    * Gets current statistics of the lock manager
 84 |    *
 85 |    * @param stats A JSON object where the statistics are stored into
 86 |    */
 87 |   void GetStats(rapidjson::Document& stats, uint32_t level) const;
 88 | 
 89 |  private:
 90 |   struct TxnInfo {
 91 |     TxnInfo(int num_keys) : num_waiting_for(num_keys) { keys.reserve(num_keys); }
 92 | 
 93 |     bool is_ready() const { return num_waiting_for == 0; }
 94 | 
 95 |     int num_waiting_for;
 96 |     std::vector<Key> keys;
 97 |   };
 98 |   unordered_map<TxnId, TxnInfo> txn_info_;
 99 |   unordered_map<Key, OldLockState> lock_table_;
100 |   uint32_t num_locked_keys_ = 0;
101 | };
102 | 
103 | }  // namespace slog


--------------------------------------------------------------------------------
/module/scheduler_components/per_key_remaster_manager.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <unordered_map>
 4 | 
 5 | #include "module/scheduler_components/remaster_manager.h"
 6 | 
 7 | using std::pair;
 8 | using std::unordered_map;
 9 | using std::unordered_set;
10 | 
11 | namespace slog {
12 | 
13 | /**
14 |  * Alternative implementation of remastering. Txns only block if they have a high counter, or if
15 |  * a transaction with a high counter arrived first with an overlapping read/write set.
16 |  * With small transactions, should acheive lower latency than SimpleRemasterManager. For large
17 |  * transactions, the overhead of creating queues may be too high.
18 |  */
19 | class PerKeyRemasterManager : public RemasterManager {
20 |  public:
21 |   PerKeyRemasterManager() = default;
22 |   PerKeyRemasterManager(const shared_ptr<const Storage>& storage);
23 | 
24 |   VerifyMasterResult VerifyMaster(Transaction& txn) final;
25 |   RemasterOccurredResult RemasterOccured(const Key& key, uint32_t remaster_counter) final;
26 |   RemasterOccurredResult ReleaseTransaction(const Transaction& txn) final;
27 | 
28 |   void SetStorage(const shared_ptr<const Storage>& storage) { storage_ = storage; }
29 | 
30 |  private:
31 |   /**
32 |    * Insert the key into the priority queue sorted by counter. This way remasters can
33 |    * unblock txns starting from the front of the queue, and stop when they reach a
34 |    * larger counter.
35 |    */
36 |   void InsertIntoBlockedQueue(const Key& key, uint32_t counter, Transaction& txn);
37 | 
38 |   /**
39 |    * Test if the head of this queue can be unblocked
40 |    */
41 |   void TryToUnblock(const Key& unblocked_key, RemasterOccurredResult& result);
42 | 
43 |   // Needs access to storage to check counters
44 |   shared_ptr<const Storage> storage_;
45 | 
46 |   // Priority queues for the transactions waiting for each key. Lowest counters first, earliest
47 |   // arrivals break tie
48 |   unordered_map<Key, list<pair<Transaction*, uint32_t>>> blocked_queue_;
49 | };
50 | 
51 | }  // namespace slog


--------------------------------------------------------------------------------
/module/scheduler_components/remaster_manager.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <glog/logging.h>
  4 | 
  5 | #include <list>
  6 | 
  7 | #include "common/types.h"
  8 | #include "module/scheduler_components/txn_holder.h"
  9 | #include "storage/storage.h"
 10 | 
 11 | using std::list;
 12 | using std::shared_ptr;
 13 | 
 14 | namespace slog {
 15 | 
 16 | enum class VerifyMasterResult { VALID, WAITING, ABORT };
 17 | struct RemasterOccurredResult {
 18 |   list<Transaction*> unblocked;
 19 |   list<Transaction*> should_abort;
 20 | };
 21 | 
 22 | /**
 23 |  * The remaster queue manager conducts the check of master metadata.
 24 |  * If a remaster has occured since the transaction was forwarded, it may
 25 |  * need to be restarted. If the transaction arrived before a remaster that
 26 |  * the forwarder included in the metadata, then it will need to wait.
 27 |  */
 28 | class RemasterManager {
 29 |  public:
 30 |   virtual ~RemasterManager() = default;
 31 | 
 32 |   /**
 33 |    * Checks the counters of the transaction's master metadata.
 34 |    *
 35 |    * @param txn Transaction to be checked
 36 |    * @return The result of the check.
 37 |    * - If Valid, the transaction can be sent for locks.
 38 |    * - If Waiting, the transaction will be queued until a remaster
 39 |    * txn unblocks it
 40 |    * - If Aborted, the counters were behind and the transaction
 41 |    * needs to be aborted.
 42 |    */
 43 |   virtual VerifyMasterResult VerifyMaster(Transaction& txn) = 0;
 44 | 
 45 |   /**
 46 |    * Updates the queue of transactions waiting for remasters,
 47 |    * and returns any newly unblocked transactions.
 48 |    *
 49 |    * @param key The key that has been remastered
 50 |    * @param remaster_counter The key's new counter
 51 |    * @return A queue of transactions that are now unblocked, in the
 52 |    * order they were submitted
 53 |    */
 54 |   virtual RemasterOccurredResult RemasterOccured(const Key& key, uint32_t remaster_counter) = 0;
 55 | 
 56 |   /**
 57 |    * Release a transaction from remaster queues. It's guaranteed that the released transaction
 58 |    * will not be in the returned result.
 59 |    *
 60 |    * @return Transactions that are now unblocked
 61 |    */
 62 |   virtual RemasterOccurredResult ReleaseTransaction(const Transaction& txn) = 0;
 63 | 
 64 |   /**
 65 |    * Compare transaction metadata to stored metadata, without adding the
 66 |    * transaction to any queues
 67 |    */
 68 |   static VerifyMasterResult CheckCounters(const Transaction& txn, bool filter_by_home,
 69 |                                           const shared_ptr<const Storage>& storage) {
 70 |     auto waiting = false;
 71 |     for (const auto& kv : txn.keys()) {
 72 |       const auto& key = kv.key();
 73 |       const auto& value = kv.value_entry();
 74 |       if (filter_by_home && static_cast<int>(value.metadata().master()) != txn.internal().home()) {
 75 |         continue;
 76 |       }
 77 |       // Get current counter from storage
 78 |       uint32_t storage_counter = 0;  // default to 0 for a new key
 79 |       Record record;
 80 |       bool found = storage->Read(key, record);
 81 |       if (found) {
 82 |         storage_counter = record.metadata().counter;
 83 |       }
 84 | 
 85 |       if (value.metadata().counter() < storage_counter) {
 86 |         return VerifyMasterResult::ABORT;
 87 |       } else if (value.metadata().counter() > storage_counter) {
 88 |         waiting = true;
 89 |       } else {
 90 |         CHECK(value.metadata().master() == record.metadata().master)
 91 |             << "Masters don't match for same key \"" << key << "\". In txn: " << value.metadata().master()
 92 |             << ". In storage: " << record.metadata().master;
 93 |       }
 94 |     }
 95 | 
 96 |     return waiting ? VerifyMasterResult::WAITING : VerifyMasterResult::VALID;
 97 |   }
 98 | };
 99 | 
100 | }  // namespace slog
101 | 


--------------------------------------------------------------------------------
/module/scheduler_components/rma_lock_manager.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | // Prevent mixing with deprecated version
  4 | #ifdef LOCK_MANAGER
  5 | #error "Only one lock manager can be included"
  6 | #endif
  7 | #define LOCK_MANAGER
  8 | 
  9 | #include <list>
 10 | #include <unordered_map>
 11 | #include <unordered_set>
 12 | #include <vector>
 13 | 
 14 | #include "common/configuration.h"
 15 | #include "common/constants.h"
 16 | #include "common/json_utils.h"
 17 | #include "common/types.h"
 18 | #include "module/scheduler_components/txn_holder.h"
 19 | 
 20 | using std::list;
 21 | using std::pair;
 22 | using std::shared_ptr;
 23 | using std::unordered_map;
 24 | using std::unordered_set;
 25 | using std::vector;
 26 | 
 27 | namespace slog {
 28 | 
 29 | /**
 30 |  * An object of this class represents the locking state of a key.
 31 |  * It contains the IDs of transactions that are holding and waiting
 32 |  * the lock and the mode of the lock.
 33 |  */
 34 | class LockState {
 35 |  public:
 36 |   bool AcquireReadLock(TxnId txn_id);
 37 |   bool AcquireWriteLock(TxnId txn_id);
 38 |   vector<TxnId> Release(TxnId txn_id);
 39 |   bool Contains(TxnId txn_id);
 40 | 
 41 |   LockMode mode = LockMode::UNLOCKED;
 42 | 
 43 |   /* For debugging */
 44 |   const vector<TxnId>& GetHolders() const { return holders_; }
 45 | 
 46 |   /* For debugging */
 47 |   const list<pair<TxnId, LockMode>>& GetWaiters() const { return waiter_queue_; }
 48 | 
 49 |  private:
 50 |   vector<TxnId> holders_;
 51 |   list<pair<TxnId, LockMode>> waiter_queue_;
 52 | };
 53 | 
 54 | /**
 55 |  * This is a deterministic lock manager which grants locks for transactions
 56 |  * in the order that they request. If transaction X, appears before
 57 |  * transaction Y in the log, X always gets all locks before Y.
 58 |  *
 59 |  * RMA stands for Remaster Aware. With this lock manager, we don't need
 60 |  * a separate remaster manager.
 61 |  *
 62 |  * Remastering:
 63 |  * Locks are taken on the tuple <key, replica>, using the transaction's
 64 |  * master metadata. The masters are checked in the worker, so if two
 65 |  * transactions hold separate locks for the same key, then one has an
 66 |  * incorrect master and will be aborted. Remaster transactions request the
 67 |  * locks for both <key, old replica> and <key, new replica>.
 68 |  */
 69 | class RMALockManager {
 70 |  public:
 71 |   RMALockManager();
 72 | 
 73 |   /**
 74 |    * Tries to acquire all locks for a given transaction. If not
 75 |    * all locks are acquired, the transaction is queued up to wait
 76 |    * for the current lock holders to release.
 77 |    *
 78 |    * @param txn The transaction whose locks are acquired.
 79 |    * @return    true if all locks are acquired, false if not and
 80 |    *            the transaction is queued up.
 81 |    */
 82 |   AcquireLocksResult AcquireLocks(const Transaction& txn);
 83 | 
 84 |   /**
 85 |    * Releases all locks that a transaction is holding or waiting for.
 86 |    *
 87 |    * @param txn_id Id of transaction whose locks are released.
 88 |    * @return       A set of IDs of transactions that are able to obtain
 89 |    *               all of their locks thanks to this release.
 90 |    */
 91 |   vector<TxnId> ReleaseLocks(TxnId txn_id);
 92 | 
 93 |   /**
 94 |    * Gets current statistics of the lock manager
 95 |    *
 96 |    * @param stats A JSON object where the statistics are stored into
 97 |    */
 98 |   void GetStats(rapidjson::Document& stats, uint32_t level) const;
 99 | 
100 |  private:
101 |   struct TxnInfo {
102 |     TxnInfo(int num_keys) : num_waiting_for(num_keys) { keys.reserve(num_keys); }
103 | 
104 |     bool is_ready() const { return num_waiting_for == 0; }
105 | 
106 |     int num_waiting_for;
107 |     std::vector<Key> keys;
108 |   };
109 |   unordered_map<TxnId, TxnInfo> txn_info_;
110 |   unordered_map<KeyReplica, LockState> lock_table_;
111 |   uint32_t num_locked_keys_ = 0;
112 | };
113 | 
114 | }  // namespace slog


--------------------------------------------------------------------------------
/module/scheduler_components/simple_remaster_manager.cpp:
--------------------------------------------------------------------------------
  1 | #include "module/scheduler_components/simple_remaster_manager.h"
  2 | 
  3 | #include <glog/logging.h>
  4 | 
  5 | namespace slog {
  6 | 
  7 | SimpleRemasterManager::SimpleRemasterManager(const shared_ptr<const Storage>& storage) : storage_(storage) {}
  8 | 
  9 | VerifyMasterResult SimpleRemasterManager::VerifyMaster(Transaction& txn) {
 10 |   if (txn.keys().empty()) {
 11 |     return VerifyMasterResult::VALID;
 12 |   }
 13 | 
 14 |   // Block this txn behind other txns from same local log
 15 |   // TODO: check the counters now? would abort earlier
 16 |   auto it = blocked_queue_.find(txn.internal().home());
 17 |   if (it != blocked_queue_.end() && !it->second.empty()) {
 18 |     it->second.push_back(&txn);
 19 |     return VerifyMasterResult::WAITING;
 20 |   }
 21 | 
 22 |   // Test counters
 23 |   auto result = CheckCounters(txn, true, storage_);
 24 |   if (result == VerifyMasterResult::WAITING) {
 25 |     blocked_queue_[txn.internal().home()].push_back(&txn);
 26 |   }
 27 |   return result;
 28 | }
 29 | 
 30 | RemasterOccurredResult SimpleRemasterManager::RemasterOccured(const Key& remaster_key,
 31 |                                                               uint32_t /* remaster_counter */) {
 32 |   RemasterOccurredResult result;
 33 |   // Try to unblock each txn at the head of a queue, if it contains the remastered key.
 34 |   // Note that multiple queues could contain the same key with different counters
 35 |   for (auto& queue_pair : blocked_queue_) {
 36 |     if (!queue_pair.second.empty()) {
 37 |       auto txn = queue_pair.second.front();
 38 |       for (const auto& kv : txn->keys()) {
 39 |         if (static_cast<int>(kv.value_entry().metadata().master()) == txn->internal().home() &&
 40 |             kv.key() == remaster_key) {
 41 |           // TODO: check here if counters match, saves an iteration through all keys
 42 |           TryToUnblock(queue_pair.first, result);
 43 |           break;
 44 |         }
 45 |       }
 46 |     }
 47 |   }
 48 |   return result;
 49 | }
 50 | 
 51 | RemasterOccurredResult SimpleRemasterManager::ReleaseTransaction(const Transaction& txn) {
 52 |   auto& txn_internal = txn.internal();
 53 |   for (auto replica : txn_internal.involved_replicas()) {
 54 |     auto it = blocked_queue_.find(replica);
 55 |     if (it == blocked_queue_.end() || it->second.empty()) {
 56 |       continue;
 57 |     }
 58 |     auto& queue = it->second;
 59 |     for (auto itr = queue.begin(); itr != queue.end(); itr++) {
 60 |       if ((*itr)->internal().id() == txn_internal.id()) {
 61 |         queue.erase(itr);
 62 |         break;  // Any transaction should only occur once per queue
 63 |       }
 64 |     }
 65 |   }
 66 | 
 67 |   // Note: this must happen after the transaction is released, otherwise it could be returned in
 68 |   // the unblocked list
 69 |   RemasterOccurredResult result;
 70 |   for (auto replica : txn_internal.involved_replicas()) {
 71 |     // TODO: only necessary if a removed txn was front of the queue
 72 |     TryToUnblock(replica, result);
 73 |   }
 74 |   return result;
 75 | }
 76 | 
 77 | void SimpleRemasterManager::TryToUnblock(uint32_t local_log_machine_id, RemasterOccurredResult& result) {
 78 |   auto it = blocked_queue_.find(local_log_machine_id);
 79 |   if (it == blocked_queue_.end() || it->second.empty()) {
 80 |     return;
 81 |   }
 82 | 
 83 |   auto lo_txn = it->second.front();
 84 | 
 85 |   auto counter_result = CheckCounters(*lo_txn, true, storage_);
 86 |   if (counter_result == VerifyMasterResult::WAITING) {
 87 |     return;
 88 |   } else if (counter_result == VerifyMasterResult::VALID) {
 89 |     result.unblocked.push_back(lo_txn);
 90 |   } else if (counter_result == VerifyMasterResult::ABORT) {
 91 |     result.should_abort.push_back(lo_txn);
 92 |   }
 93 | 
 94 |   // Head of queue has changed
 95 |   it->second.pop_front();
 96 | 
 97 |   // Note: queue may be left empty, since there are not many replicas
 98 |   TryToUnblock(local_log_machine_id, result);
 99 | }
100 | 
101 | }  // namespace slog
102 | 


--------------------------------------------------------------------------------
/module/scheduler_components/simple_remaster_manager.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <unordered_map>
 4 | 
 5 | #include "module/scheduler_components/remaster_manager.h"
 6 | 
 7 | using std::unordered_map;
 8 | using std::unordered_set;
 9 | 
10 | namespace slog {
11 | 
12 | /**
13 |  * Basic, inefficient implimentation of remastering. Transactions are kept in the exact
14 |  * order as their local logs: if a transaction from region 1 is blocked in the queue, all
15 |  * following transactions from region 1 will be blocked behind it
16 |  */
17 | class SimpleRemasterManager : public RemasterManager {
18 |  public:
19 |   SimpleRemasterManager() = default;
20 |   SimpleRemasterManager(const shared_ptr<const Storage>& storage);
21 | 
22 |   VerifyMasterResult VerifyMaster(Transaction& txn) final;
23 |   RemasterOccurredResult RemasterOccured(const Key& key, uint32_t remaster_counter) final;
24 |   RemasterOccurredResult ReleaseTransaction(const Transaction& txn_holder) final;
25 | 
26 |   void SetStorage(const shared_ptr<const Storage>& storage) { storage_ = storage; }
27 | 
28 |  private:
29 |   /**
30 |    * Test if the head of this queue can be unblocked
31 |    */
32 |   void TryToUnblock(uint32_t local_log_machine_id, RemasterOccurredResult& result);
33 | 
34 |   // Needs access to storage to check counters
35 |   shared_ptr<const Storage> storage_;
36 | 
37 |   // One queue is kept per local log
38 |   unordered_map<uint32_t, list<Transaction*>> blocked_queue_;
39 | };
40 | 
41 | }  // namespace slog
42 | 


--------------------------------------------------------------------------------
/module/scheduler_components/txn_holder.cpp:
--------------------------------------------------------------------------------
 1 | #include "module/scheduler_components/txn_holder.h"
 2 | 
 3 | namespace slog {
 4 | 
 5 | TxnHolder::TxnHolder(const ConfigurationPtr& config, Transaction* txn)
 6 |     : txn_id_(txn->internal().id()),
 7 |       main_txn_idx_(txn->internal().home()),
 8 |       lo_txns_(config->num_replicas()),
 9 |       remaster_result_(std::nullopt),
10 |       aborting_(false),
11 |       done_(false),
12 |       num_lo_txns_(0),
13 |       expected_num_lo_txns_(txn->internal().involved_replicas_size()),
14 |       num_dispatches_(0) {
15 |   lo_txns_[main_txn_idx_].reset(txn);
16 |   ++num_lo_txns_;
17 | }
18 | 
19 | bool TxnHolder::AddLockOnlyTxn(Transaction* txn) {
20 |   auto home = txn->internal().home();
21 |   CHECK_LT(home, static_cast<int>(lo_txns_.size()));
22 | 
23 |   if (lo_txns_[home] != nullptr) {
24 |     return false;
25 |   }
26 | 
27 |   lo_txns_[home].reset(txn);
28 | 
29 |   ++num_lo_txns_;
30 | 
31 |   return true;
32 | }
33 | 
34 | Transaction* TxnHolder::FinalizeAndRelease() {
35 |   auto& main_txn = lo_txns_[main_txn_idx_];
36 |   auto main_internal = main_txn->mutable_internal();
37 |   int cutoff = main_internal->events_size();
38 |   for (auto& lo_txn : lo_txns_) {
39 |     if (lo_txn != nullptr) {
40 |       auto internal = lo_txn->mutable_internal();
41 | 
42 |       // Set the "home" field of each event and determine the cutoff point
43 |       // before which the current txn shares the same events as the main txn
44 |       for (int i = 0; i < internal->events_size(); i++) {
45 |         auto event = internal->mutable_events(i);
46 |         event->set_home(internal->home());
47 | 
48 |         if (i < cutoff) {
49 |           const auto& main_txn_event = main_internal->events(i);
50 |           if (event->event() != main_txn_event.event() || event->time() != main_txn_event.time() ||
51 |               event->machine() != main_txn_event.machine()) {
52 |             cutoff = i;
53 |           }
54 |         }
55 |       }
56 |     }
57 |   }
58 | 
59 |   for (auto& lo_txn : lo_txns_) {
60 |     if (lo_txn != nullptr && lo_txn != main_txn) {
61 |       auto internal = lo_txn->mutable_internal();
62 |       // Only transfer the events after the cutoff point to the main txn
63 |       for (int i = cutoff; i < internal->events_size(); i++) {
64 |         main_internal->mutable_events()->AddAllocated(internal->mutable_events(i));
65 |       }
66 |       while (internal->events_size() > cutoff) {
67 |         internal->mutable_events()->ReleaseLast();
68 |       }
69 |       lo_txn.reset();
70 |     }
71 |   }
72 | 
73 |   // Do not use clear() here because lo_txns_ must never change in size
74 |   return lo_txns_[main_txn_idx_].release();
75 | }
76 | 
77 | }  // namespace slog


--------------------------------------------------------------------------------
/module/scheduler_components/txn_holder.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <glog/logging.h>
 4 | 
 5 | #include <optional>
 6 | #include <vector>
 7 | 
 8 | #include "common/configuration.h"
 9 | #include "common/proto_utils.h"
10 | #include "common/types.h"
11 | #include "proto/transaction.pb.h"
12 | 
13 | namespace slog {
14 | 
15 | using EnvelopePtr = std::unique_ptr<internal::Envelope>;
16 | 
17 | class TxnHolder {
18 |  public:
19 |   TxnHolder(const ConfigurationPtr& config, Transaction* txn);
20 | 
21 |   bool AddLockOnlyTxn(Transaction* txn);
22 | 
23 |   Transaction* FinalizeAndRelease();
24 | 
25 |   TxnId txn_id() const { return txn_id_; }
26 |   Transaction& txn() const {
27 |     CHECK(lo_txns_[main_txn_idx_] != nullptr);
28 |     return *lo_txns_[main_txn_idx_];
29 |   }
30 |   Transaction& lock_only_txn(size_t i) const { return *lo_txns_[i]; }
31 | 
32 |   void SetRemasterResult(const Key& key, uint32_t counter) { remaster_result_.emplace(key, counter); }
33 |   std::optional<pair<Key, uint32_t>> remaster_result() const { return remaster_result_; }
34 | 
35 |   void SetDone() { done_ = true; }
36 |   bool is_done() const { return done_; }
37 | 
38 |   void SetAborting() { aborting_ = true; }
39 |   bool is_aborting() const { return aborting_; }
40 | 
41 |   void IncNumDispatches() { num_dispatches_++; }
42 |   int num_dispatches() const { return num_dispatches_; }
43 | 
44 |   bool is_ready_for_gc() const { return done_ && num_lo_txns_ == expected_num_lo_txns_; }
45 |   int num_lock_only_txns() const { return num_lo_txns_; }
46 |   int expected_num_lock_only_txns() const { return expected_num_lo_txns_; }
47 | 
48 |  private:
49 |   TxnId txn_id_;
50 |   size_t main_txn_idx_;
51 |   std::vector<std::unique_ptr<Transaction>> lo_txns_;
52 |   std::optional<pair<Key, uint32_t>> remaster_result_;
53 |   bool aborting_;
54 |   bool done_;
55 |   int num_lo_txns_;
56 |   int expected_num_lo_txns_;
57 |   int num_dispatches_;
58 | };
59 | 
60 | }  // namespace slog


--------------------------------------------------------------------------------
/module/scheduler_components/worker.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <functional>
 4 | #include <optional>
 5 | #include <unordered_map>
 6 | #include <unordered_set>
 7 | #include <zmq.hpp>
 8 | 
 9 | #include "common/configuration.h"
10 | #include "common/metrics.h"
11 | #include "common/types.h"
12 | #include "execution/execution.h"
13 | #include "module/base/networked_module.h"
14 | #include "module/scheduler_components/txn_holder.h"
15 | #include "proto/internal.pb.h"
16 | #include "proto/transaction.pb.h"
17 | #include "storage/storage.h"
18 | 
19 | namespace slog {
20 | 
21 | struct TransactionState {
22 |   enum class Phase { READ_LOCAL_STORAGE, WAIT_REMOTE_READ, EXECUTE, FINISH };
23 | 
24 |   TransactionState(TxnHolder* txn_holder)
25 |       : txn_holder(txn_holder), remote_reads_waiting_on(0), phase(Phase::READ_LOCAL_STORAGE) {}
26 |   TxnHolder* txn_holder;
27 |   uint32_t remote_reads_waiting_on;
28 |   Phase phase;
29 | };
30 | 
31 | /**
32 |  * A worker executes and commits transactions. Every time it receives from
33 |  * the scheduler a message pertaining to a transaction X, it will either
34 |  * initializes the state for X if X is a new transaction or try to advance
35 |  * X to the subsequent phases as much as possible.
36 |  */
37 | class Worker : public NetworkedModule {
38 |  public:
39 |   Worker(int id, const std::shared_ptr<Broker>& broker, const std::shared_ptr<Storage>& storage,
40 |          const MetricsRepositoryManagerPtr& metrics_manager,
41 |          std::chrono::milliseconds poll_timeout_ms = kModuleTimeout);
42 | 
43 |   std::string name() const override { return "Worker-" + std::to_string(channel()); }
44 | 
45 |  protected:
46 |   void Initialize() final;
47 |   /**
48 |    * Applies remote read for transactions that are in the WAIT_REMOTE_READ phase.
49 |    * When all remote reads are received, the transaction is moved to the EXECUTE phase.
50 |    */
51 |   void OnInternalRequestReceived(EnvelopePtr&& env) final;
52 | 
53 |   /**
54 |    * Receives new transaction from the scheduler
55 |    */
56 |   bool OnCustomSocket() final;
57 | 
58 |  private:
59 |   /**
60 |    * Drives most of the phase transition of a transaction
61 |    */
62 |   void AdvanceTransaction(TxnId txn_id);
63 | 
64 |   /**
65 |    * Checks master metadata information and reads local data to the transaction
66 |    * buffer, then broadcast local data to other partitions
67 |    */
68 |   void ReadLocalStorage(TxnId txn_id);
69 | 
70 |   /**
71 |    * Executes the code inside the transaction
72 |    */
73 |   void Execute(TxnId txn_id);
74 | 
75 |   /**
76 |    * Returns the result back to the scheduler and cleans up the transaction state
77 |    */
78 |   void Finish(TxnId txn_id);
79 | 
80 |   void NotifyOtherPartitions(TxnId txn_id);
81 | 
82 |   // Precondition: txn_id must exists in txn states table
83 |   TransactionState& TxnState(TxnId txn_id);
84 | 
85 |   std::shared_ptr<Storage> storage_;
86 |   std::unique_ptr<Execution> execution_;
87 | 
88 |   std::unordered_map<TxnId, TransactionState> txn_states_;
89 | };
90 | 
91 | }  // namespace slog


--------------------------------------------------------------------------------
/module/sequencer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <list>
 4 | #include <random>
 5 | 
 6 | #include "common/configuration.h"
 7 | #include "common/metrics.h"
 8 | #include "common/sharder.h"
 9 | #include "common/types.h"
10 | #include "connection/broker.h"
11 | #include "module/base/networked_module.h"
12 | 
13 | namespace slog {
14 | 
15 | /**
16 |  * A Sequencer batches transactions before sending to the Interleaver.
17 |  *
18 |  * INPUT:  ForwardTxn
19 |  *
20 |  * OUTPUT: For a single-home txn, it is put into a batch. The ID of this batch is
21 |  *         sent to the local paxos process for ordering. Simultaneously, this batch
22 |  *         is sent to the Interleaver of all machines across all regions.
23 |  *
24 |  *         For a multi-home txn, a corresponding lock-only txn is created and then goes
25 |  *         through the same process as a single-home txn above.
26 |  */
27 | class Sequencer : public NetworkedModule {
28 |  public:
29 |   Sequencer(const std::shared_ptr<zmq::context_t>& context, const ConfigurationPtr& config,
30 |             const MetricsRepositoryManagerPtr& metrics_manager,
31 |             std::chrono::milliseconds poll_timeout = kModuleTimeout);
32 | 
33 |   std::string name() const override { return "Sequencer"; }
34 | 
35 |  protected:
36 |   void OnInternalRequestReceived(EnvelopePtr&& env) final;
37 | 
38 |  private:
39 |   using PartitionedBatch = std::vector<std::unique_ptr<internal::Batch>>;
40 | 
41 |   void BatchTxn(Transaction* txn);
42 |   void ProcessStatsRequest(const internal::StatsRequest& stats_request);
43 | 
44 |   void StartOver();
45 |   void NewBatch();
46 |   BatchId batch_id() const { return batch_id_counter_ * kMaxNumMachines + config()->local_machine_id(); }
47 |   void SendBatches();
48 |   EnvelopePtr NewBatchForwardingMessage(std::vector<internal::Batch*>&& batch, int home_position);
49 | 
50 |   const SharderPtr sharder_;
51 |   std::vector<PartitionedBatch> batches_;
52 |   BatchId batch_id_counter_;
53 |   int current_batch_size_;
54 |   int total_batch_size_;
55 | 
56 |   std::mt19937 rg_;
57 | 
58 |   bool collecting_stats_;
59 |   std::chrono::steady_clock::time_point batch_starting_time_;
60 |   std::vector<int> stat_batch_sizes_;
61 |   std::vector<float> stat_batch_durations_ms_;
62 | };
63 | 
64 | }  // namespace slog


--------------------------------------------------------------------------------
/module/server.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <glog/logging.h>
 4 | 
 5 | #include <chrono>
 6 | #include <set>
 7 | #include <thread>
 8 | #include <unordered_map>
 9 | #include <unordered_set>
10 | #include <vector>
11 | #include <zmq.hpp>
12 | 
13 | #include "common/configuration.h"
14 | #include "common/proto_utils.h"
15 | #include "common/types.h"
16 | #include "connection/broker.h"
17 | #include "module/base/networked_module.h"
18 | #include "proto/api.pb.h"
19 | #include "storage/lookup_master_index.h"
20 | 
21 | namespace slog {
22 | 
23 | /**
24 |  * A Server serves external requests from the clients.
25 |  *
26 |  * INPUT:  External TransactionRequest
27 |  *
28 |  * OUTPUT: For external TransactionRequest, it forwards the txn internally
29 |  *         to appropriate modules and waits for internal responses before
30 |  *         responding back to the client with an external TransactionResponse.
31 |  */
32 | class Server : public NetworkedModule {
33 |  public:
34 |   Server(const std::shared_ptr<Broker>& broker, const MetricsRepositoryManagerPtr& metrics_manager,
35 |          std::chrono::milliseconds poll_timeout = kModuleTimeout);
36 | 
37 |   std::string name() const override { return "Server"; }
38 | 
39 |  protected:
40 |   void Initialize() final;
41 | 
42 |   /**
43 |    * After a transaction is processed by different partitions, each
44 |    * involving partition will send a sub-transaction with the processing
45 |    * result to the coordinating server. The coordinating server will be
46 |    * in charge of merging these sub-transactions and responding back to
47 |    * the client.
48 |    */
49 |   void OnInternalRequestReceived(EnvelopePtr&& env) final;
50 | 
51 |   void OnInternalResponseReceived(EnvelopePtr&& env) final;
52 | 
53 |   bool OnCustomSocket() final;
54 | 
55 |  private:
56 |   void ProcessFinishedSubtxn(EnvelopePtr&& req);
57 |   void ProcessStatsRequest(const internal::StatsRequest& stats_request);
58 | 
59 |   void SendTxnToClient(Transaction* txn);
60 |   void SendResponseToClient(TxnId txn_id, api::Response&& res);
61 | 
62 |   TxnId NextTxnId();
63 | 
64 |   TxnId txn_id_counter_;
65 | 
66 |   struct PendingResponse {
67 |     zmq::message_t identity;
68 |     uint32_t stream_id;
69 | 
70 |     explicit PendingResponse(zmq::message_t&& identity, uint32_t stream_id)
71 |         : identity(std::move(identity)), stream_id(stream_id) {}
72 |   };
73 |   std::unordered_map<TxnId, PendingResponse> pending_responses_;
74 | 
75 |   class FinishedTransaction {
76 |    public:
77 |     FinishedTransaction(size_t involved_partitions);
78 |     bool AddSubTxn(EnvelopePtr&& new_req, uint32_t part);
79 |     Transaction* ReleaseTxn();
80 | 
81 |    private:
82 |     EnvelopePtr req_;
83 |     size_t remaining_partitions_;
84 |   };
85 |   std::unordered_map<TxnId, FinishedTransaction> finished_txns_;
86 | 
87 |   std::unordered_set<MachineId> offline_machines_;
88 | };
89 | 
90 | }  // namespace slog


--------------------------------------------------------------------------------
/module/txn_generator.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <glog/logging.h>
  4 | 
  5 | #include <atomic>
  6 | #include <vector>
  7 | #include <zmq.hpp>
  8 | 
  9 | #include "connection/poller.h"
 10 | #include "module/base/module.h"
 11 | #include "workload/workload.h"
 12 | 
 13 | namespace slog {
 14 | 
 15 | class TxnGenerator {
 16 |  public:
 17 |   struct TxnInfo {
 18 |     Transaction* txn = nullptr;
 19 |     TransactionProfile profile;
 20 |     std::chrono::system_clock::time_point sent_at;
 21 |     std::chrono::system_clock::time_point recv_at;
 22 |     bool finished = false;
 23 |     int generator_id;
 24 |   };
 25 | 
 26 |   TxnGenerator(std::unique_ptr<Workload>&& workload);
 27 |   const Workload& workload() const;
 28 |   size_t num_sent_txns() const;
 29 |   size_t num_recv_txns() const;
 30 |   std::chrono::nanoseconds elapsed_time() const;
 31 | 
 32 |   virtual const std::vector<TxnInfo>& txn_infos() const = 0;
 33 | 
 34 |  protected:
 35 |   void StartTimer();
 36 |   void StopTimer();
 37 |   bool timer_running() const;
 38 | 
 39 |   int id_;
 40 |   std::unique_ptr<Workload> workload_;
 41 |   std::atomic<size_t> num_sent_txns_;
 42 |   std::atomic<size_t> num_recv_txns_;
 43 | 
 44 |  private:
 45 |   std::chrono::steady_clock::time_point start_time_;
 46 |   std::atomic<std::chrono::nanoseconds> elapsed_time_;
 47 |   bool timer_running_;
 48 | };
 49 | 
 50 | // This generators simulates synchronous clients, each of which sends a new
 51 | // txn only after it receives response from the previous txn
 52 | class SynchronousTxnGenerator : public Module, public TxnGenerator {
 53 |  public:
 54 |   /**
 55 |    * If num_txns is set to 0, the txns are generated on-the-fly
 56 |    */
 57 |   SynchronousTxnGenerator(const ConfigurationPtr& config, zmq::context_t& context, std::unique_ptr<Workload>&& workload,
 58 |                           uint32_t region, uint32_t num_txns, int num_clients, int duration_s, int startup_spacing_us,
 59 |                           bool dry_run);
 60 |   ~SynchronousTxnGenerator();
 61 |   void SetUp() final;
 62 |   bool Loop() final;
 63 |   const std::vector<TxnInfo>& txn_infos() const final { return txns_; }
 64 |   std::string name() const final { return "Synchronous-Txn-Generator"; }
 65 | 
 66 |  private:
 67 |   void SendNextTxn();
 68 | 
 69 |   ConfigurationPtr config_;
 70 |   zmq::socket_t socket_;
 71 |   Poller poller_;
 72 |   uint32_t region_;
 73 |   uint32_t num_txns_;
 74 |   int num_clients_;
 75 |   std::chrono::microseconds startup_spacing_;
 76 |   std::chrono::milliseconds duration_;
 77 |   bool dry_run_;
 78 |   std::vector<std::pair<Transaction*, TransactionProfile>> generated_txns_;
 79 |   std::vector<TxnInfo> txns_;
 80 | };
 81 | 
 82 | // This generator sends txn at a constant rate
 83 | class ConstantRateTxnGenerator : public Module, public TxnGenerator {
 84 |  public:
 85 |   ConstantRateTxnGenerator(const ConfigurationPtr& config, zmq::context_t& context,
 86 |                            std::unique_ptr<Workload>&& workload, uint32_t region, uint32_t num_txns, int tps,
 87 |                            int duration_s, bool dry_run);
 88 |   ~ConstantRateTxnGenerator();
 89 |   void SetUp() final;
 90 |   bool Loop() final;
 91 |   const std::vector<TxnInfo>& txn_infos() const final { return txns_; }
 92 |   std::string name() const final { return "Constant-Txn-Generator"; }
 93 | 
 94 |  private:
 95 |   void SendNextTxn();
 96 | 
 97 |   ConfigurationPtr config_;
 98 |   zmq::socket_t socket_;
 99 |   Poller poller_;
100 |   std::chrono::microseconds interval_;
101 |   uint32_t region_;
102 |   uint32_t num_txns_;
103 |   std::chrono::milliseconds duration_;
104 |   bool dry_run_;
105 | 
106 |   std::vector<std::pair<Transaction*, TransactionProfile>> generated_txns_;
107 |   std::vector<TxnInfo> txns_;
108 | };
109 | 
110 | }  // namespace slog


--------------------------------------------------------------------------------
/paxos/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | target_sources(slog-core
2 |   PRIVATE
3 |     acceptor.cpp
4 |     acceptor.h
5 |     leader.cpp
6 |     leader.h
7 |     simulated_multi_paxos.cpp
8 |     simulated_multi_paxos.h)


--------------------------------------------------------------------------------
/paxos/acceptor.cpp:
--------------------------------------------------------------------------------
 1 | #include "paxos/acceptor.h"
 2 | 
 3 | #include "paxos/simulated_multi_paxos.h"
 4 | 
 5 | namespace slog {
 6 | 
 7 | using internal::Envelope;
 8 | using internal::Request;
 9 | using internal::Response;
10 | 
11 | Acceptor::Acceptor(SimulatedMultiPaxos& sender) : sender_(sender), ballot_(0) {}
12 | 
13 | void Acceptor::HandleRequest(const internal::Envelope& req) {
14 |   switch (req.request().type_case()) {
15 |     case Request::TypeCase::kPaxosAccept:
16 |       ProcessAcceptRequest(req.request().paxos_accept(), req.from());
17 |       break;
18 |     case Request::TypeCase::kPaxosCommit:
19 |       ProcessCommitRequest(req.request().paxos_commit(), req.from());
20 |       break;
21 |     default:
22 |       break;
23 |   }
24 | }
25 | 
26 | void Acceptor::ProcessAcceptRequest(const internal::PaxosAcceptRequest& req, MachineId from_machine_id) {
27 |   if (req.ballot() < ballot_) {
28 |     return;
29 |   }
30 |   ballot_ = req.ballot();
31 |   auto env = sender_.NewEnvelope();
32 |   auto accept_response = env->mutable_response()->mutable_paxos_accept();
33 |   accept_response->set_ballot(ballot_);
34 |   accept_response->set_slot(req.slot());
35 |   sender_.SendSameChannel(move(env), from_machine_id);
36 | }
37 | 
38 | void Acceptor::ProcessCommitRequest(const internal::PaxosCommitRequest& req, MachineId from_machine_id) {
39 |   // TODO: If leader election is implemented, this is where we erase
40 |   //       memory about an accepted value
41 |   auto env = sender_.NewEnvelope();
42 |   auto commit_response = env->mutable_response()->mutable_paxos_commit();
43 |   commit_response->set_slot(req.slot());
44 |   sender_.SendSameChannel(move(env), from_machine_id);
45 | }
46 | 
47 | }  // namespace slog


--------------------------------------------------------------------------------
/paxos/acceptor.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "common/types.h"
 4 | #include "proto/internal.pb.h"
 5 | 
 6 | using std::string;
 7 | 
 8 | namespace slog {
 9 | 
10 | class SimulatedMultiPaxos;
11 | 
12 | class Acceptor {
13 |  public:
14 |   /**
15 |    * @param sender The enclosing Paxos class
16 |    */
17 |   Acceptor(SimulatedMultiPaxos& sender);
18 | 
19 |   void HandleRequest(const internal::Envelope& req);
20 | 
21 |  private:
22 |   void ProcessAcceptRequest(const internal::PaxosAcceptRequest& req, MachineId from_machine_id);
23 | 
24 |   void ProcessCommitRequest(const internal::PaxosCommitRequest& req, MachineId from_machine_id);
25 | 
26 |   SimulatedMultiPaxos& sender_;
27 | 
28 |   uint32_t ballot_;
29 | };
30 | 
31 | }  // namespace slog


--------------------------------------------------------------------------------
/paxos/leader.cpp:
--------------------------------------------------------------------------------
  1 | #include "paxos/leader.h"
  2 | 
  3 | #include <glog/logging.h>
  4 | 
  5 | #include "common/proto_utils.h"
  6 | #include "connection/sender.h"
  7 | #include "paxos/simulated_multi_paxos.h"
  8 | 
  9 | namespace slog {
 10 | 
 11 | using internal::Envelope;
 12 | using internal::Request;
 13 | using internal::Response;
 14 | 
 15 | Leader::Leader(SimulatedMultiPaxos& paxos, const vector<MachineId>& members, MachineId me)
 16 |     : paxos_(paxos), members_(members), me_(me), next_empty_slot_(0) {
 17 |   // Number of acceptors is the largest odd number smaller than or equal to the number of members
 18 |   size_t num_acceptors_ = ((members_.size() - 1) / 2) * 2 + 1;
 19 |   for (size_t i = 0; i < num_acceptors_; i++) {
 20 |     acceptors_.push_back(members_[i]);
 21 |   }
 22 |   auto it = std::find(members.begin(), members.end(), me);
 23 |   is_member_ = it != members.end();
 24 |   if (is_member_) {
 25 |     auto position_in_members = it - members.begin();
 26 |     is_elected_ = position_in_members == kPaxosDefaultLeaderPosition;
 27 |     ballot_ = position_in_members;
 28 |   } else {
 29 |     // When the current machine is not a member of this paxos group, it
 30 |     // will always forward a proposal request to the initially elected
 31 |     // leader of the group (which would never change in this implementation
 32 |     // of paxos)
 33 |     is_elected_ = false;
 34 |   }
 35 |   elected_leader_ = members[kPaxosDefaultLeaderPosition];
 36 | }
 37 | 
 38 | void Leader::HandleRequest(const Envelope& req) {
 39 |   switch (req.request().type_case()) {
 40 |     case Request::TypeCase::kPaxosPropose:
 41 |       // If elected as true leader, send accept request to the acceptors
 42 |       // Otherwise, forward the request to the true leader
 43 |       if (is_elected_) {
 44 |         StartNewInstance(req.request().paxos_propose().value());
 45 |       } else {
 46 |         paxos_.SendSameChannel(req, elected_leader_);
 47 |       }
 48 |       break;
 49 |     case Request::TypeCase::kPaxosCommit:
 50 |       ProcessCommitRequest(req.request().paxos_commit());
 51 |       break;
 52 |     default:
 53 |       break;
 54 |   }
 55 | }
 56 | 
 57 | void Leader::ProcessCommitRequest(const internal::PaxosCommitRequest& commit) {
 58 |   auto slot = commit.slot();
 59 | 
 60 |   // Report to the paxos user
 61 |   paxos_.OnCommit(slot, commit.value(), commit.leader());
 62 | 
 63 |   if (slot >= next_empty_slot_) {
 64 |     next_empty_slot_ = slot + 1;
 65 |   }
 66 | }
 67 | 
 68 | void Leader::HandleResponse(const Envelope& res) {
 69 |   if (res.response().has_paxos_accept()) {
 70 |     auto slot = res.response().paxos_accept().slot();
 71 |     auto it = instances_.find(slot);
 72 |     if (it == instances_.end()) {
 73 |       return;
 74 |     }
 75 |     auto& instance = it->second;
 76 |     ++instance.num_accepts;
 77 | 
 78 |     if (instance.num_accepts == static_cast<int>(acceptors_.size() / 2 + 1)) {
 79 |       auto env = paxos_.NewEnvelope();
 80 |       auto paxos_commit = env->mutable_request()->mutable_paxos_commit();
 81 |       paxos_commit->set_slot(slot);
 82 |       paxos_commit->set_value(instance.value);
 83 |       paxos_commit->set_leader(me_);
 84 |       paxos_.SendSameChannel(move(env), members_);
 85 |     }
 86 |   } else if (res.response().has_paxos_commit()) {
 87 |     auto slot = res.response().paxos_accept().slot();
 88 |     auto it = instances_.find(slot);
 89 |     if (it == instances_.end()) {
 90 |       return;
 91 |     }
 92 |     auto& instance = it->second;
 93 |     ++instance.num_commits;
 94 |     if (instance.num_commits == static_cast<int>(members_.size())) {
 95 |       instances_.erase(it);
 96 |     }
 97 |   }
 98 | }
 99 | 
100 | void Leader::StartNewInstance(uint64_t value) {
101 |   instances_.try_emplace(next_empty_slot_, ballot_, value);
102 | 
103 |   auto env = paxos_.NewEnvelope();
104 |   auto paxos_accept = env->mutable_request()->mutable_paxos_accept();
105 |   paxos_accept->set_ballot(ballot_);
106 |   paxos_accept->set_slot(next_empty_slot_);
107 |   paxos_accept->set_value(value);
108 |   next_empty_slot_++;
109 | 
110 |   paxos_.SendSameChannel(move(env), acceptors_);
111 | }
112 | 
113 | bool Leader::IsMember() const { return is_member_; }
114 | 
115 | }  // namespace slog


--------------------------------------------------------------------------------
/paxos/leader.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <unordered_map>
 4 | #include <unordered_set>
 5 | #include <vector>
 6 | 
 7 | #include "common/types.h"
 8 | #include "proto/internal.pb.h"
 9 | 
10 | using std::string;
11 | using std::unique_ptr;
12 | using std::unordered_map;
13 | using std::unordered_set;
14 | using std::vector;
15 | 
16 | namespace slog {
17 | 
18 | using EnvelopePtr = unique_ptr<internal::Envelope>;
19 | 
20 | class SimulatedMultiPaxos;
21 | 
22 | struct PaxosInstance {
23 |   PaxosInstance(uint32_t ballot, uint64_t value) : ballot(ballot), value(value), num_accepts(0), num_commits(0) {}
24 | 
25 |   uint32_t ballot;
26 |   uint64_t value;
27 |   int num_accepts;
28 |   int num_commits;
29 | };
30 | 
31 | class Leader {
32 |  public:
33 |   /**
34 |    * @param paxos   The enclosing Paxos class
35 |    * @param members Machine Id of all members participating in this Paxos process
36 |    * @param me      Machine Id of the current machine
37 |    */
38 |   Leader(SimulatedMultiPaxos& paxos, const vector<MachineId>& members, MachineId me);
39 | 
40 |   void HandleRequest(const internal::Envelope& req);
41 |   void HandleResponse(const internal::Envelope& res);
42 | 
43 |   bool IsMember() const;
44 | 
45 |  private:
46 |   void ProcessCommitRequest(const internal::PaxosCommitRequest& commit);
47 |   void StartNewInstance(uint64_t value);
48 | 
49 |   SimulatedMultiPaxos& paxos_;
50 | 
51 |   const vector<MachineId> members_;
52 |   vector<MachineId> acceptors_;
53 |   const MachineId me_;
54 |   bool is_elected_;
55 |   bool is_member_;
56 |   MachineId elected_leader_;
57 | 
58 |   SlotId next_empty_slot_;
59 |   uint32_t ballot_;
60 |   unordered_map<SlotId, PaxosInstance> instances_;
61 | };
62 | }  // namespace slog


--------------------------------------------------------------------------------
/paxos/simulated_multi_paxos.cpp:
--------------------------------------------------------------------------------
 1 | #include "paxos/simulated_multi_paxos.h"
 2 | 
 3 | #include "connection/broker.h"
 4 | #include "connection/sender.h"
 5 | 
 6 | namespace slog {
 7 | 
 8 | using internal::Request;
 9 | using internal::Response;
10 | 
11 | SimulatedMultiPaxos::SimulatedMultiPaxos(Channel group_number, const shared_ptr<Broker>& broker,
12 |                                          const vector<MachineId>& members, MachineId me,
13 |                                          std::chrono::milliseconds poll_timeout)
14 |     : NetworkedModule(broker, group_number, nullptr, poll_timeout), leader_(*this, members, me), acceptor_(*this) {}
15 | 
16 | void SimulatedMultiPaxos::OnInternalRequestReceived(EnvelopePtr&& req) {
17 |   // A non-leader machine can still need to do some work to maintain its state should it becomes a leader later
18 |   leader_.HandleRequest(*req);
19 |   acceptor_.HandleRequest(*req);
20 | }
21 | 
22 | void SimulatedMultiPaxos::OnInternalResponseReceived(EnvelopePtr&& res) { leader_.HandleResponse(*res); }
23 | 
24 | bool SimulatedMultiPaxos::IsMember() const { return leader_.IsMember(); }
25 | 
26 | void SimulatedMultiPaxos::SendSameChannel(const internal::Envelope& env, MachineId to_machine_id) {
27 |   Send(env, to_machine_id, channel());
28 | }
29 | 
30 | void SimulatedMultiPaxos::SendSameChannel(EnvelopePtr&& env, MachineId to_machine_id) {
31 |   Send(std::move(env), to_machine_id, channel());
32 | }
33 | 
34 | void SimulatedMultiPaxos::SendSameChannel(EnvelopePtr&& env, const std::vector<MachineId>& to_machine_ids) {
35 |   Send(std::move(env), to_machine_ids, channel());
36 | }
37 | 
38 | }  // namespace slog


--------------------------------------------------------------------------------
/paxos/simulated_multi_paxos.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "connection/broker.h"
 4 | #include "module/base/networked_module.h"
 5 | #include "paxos/acceptor.h"
 6 | #include "paxos/leader.h"
 7 | 
 8 | using std::shared_ptr;
 9 | using std::string;
10 | 
11 | namespace slog {
12 | 
13 | class SimulatedMultiPaxos : public NetworkedModule {
14 |  public:
15 |   /**
16 |    * @param group_number  Number of the current paxos group. Used to differentiate messages
17 |    *                      from other paxos groups
18 |    * @param broker        The broker for sending and receiving messages
19 |    * @param members       Machine Id of all members participating in this Paxos process
20 |    * @param me            Machine Id of the current machine
21 |    */
22 |   SimulatedMultiPaxos(Channel group_number, const shared_ptr<Broker>& broker, const vector<MachineId>& group_members,
23 |                       MachineId me, std::chrono::milliseconds poll_timeout = kModuleTimeout);
24 | 
25 |   std::string name() const override { return "Paxos-" + std::to_string(channel()); }
26 | 
27 |   bool IsMember() const;
28 | 
29 |  protected:
30 |   void OnInternalRequestReceived(EnvelopePtr&& env) final;
31 |   void OnInternalResponseReceived(EnvelopePtr&& env) final;
32 | 
33 |   virtual void OnCommit(uint32_t slot, uint32_t value, MachineId leader) = 0;
34 | 
35 |  private:
36 |   Leader leader_;
37 |   Acceptor acceptor_;
38 | 
39 |   void SendSameChannel(const internal::Envelope& env, MachineId to_machine_id);
40 |   void SendSameChannel(EnvelopePtr&& env, MachineId to_machine_id);
41 |   void SendSameChannel(EnvelopePtr&& env, const std::vector<MachineId>& to_machine_ids);
42 | 
43 |   friend class Leader;
44 |   friend class Acceptor;
45 | };
46 | 
47 | }  // namespace slog


--------------------------------------------------------------------------------
/proto/api.proto:
--------------------------------------------------------------------------------
 1 | syntax = "proto3";
 2 | 
 3 | import "proto/modules.proto";
 4 | import "proto/transaction.proto";
 5 | 
 6 | package slog.api;
 7 | 
 8 | /***********************************************
 9 |                     REQUESTS
10 | ***********************************************/
11 | 
12 | message Request {
13 |     uint32 stream_id = 1;
14 |     oneof type {
15 |         TransactionRequest txn = 2;
16 |         StatsRequest stats = 3;
17 |         WriteMetricsRequest metrics = 4;
18 |     }
19 | }
20 | 
21 | message TransactionRequest {
22 |     Transaction txn = 1;
23 | }
24 | 
25 | message StatsRequest {
26 |     ModuleId module = 1;
27 |     // Level of details, starting from 0
28 |     uint32 level = 2;
29 | }
30 | 
31 | message WriteMetricsRequest {
32 |     bytes prefix = 1;
33 | }
34 | 
35 | /***********************************************
36 |                     RESPONSES
37 | ***********************************************/
38 | 
39 | message Response {
40 |     uint32 stream_id = 1;
41 |     oneof type {
42 |         TransactionResponse txn = 2;
43 |         StatsResponse stats = 3;
44 |         WriteMetricsResponse metrics = 4;
45 |     }
46 | }
47 | 
48 | // For debugging and testing purposes
49 | message TransactionResponse {
50 |     Transaction txn = 1;
51 | }
52 | 
53 | message StatsResponse {
54 |     bytes stats_json = 1;
55 | }
56 | 
57 | message WriteMetricsResponse {
58 | }


--------------------------------------------------------------------------------
/proto/modules.proto:
--------------------------------------------------------------------------------
 1 | syntax = "proto3";
 2 | package slog;
 3 | 
 4 | enum ModuleId {
 5 |   BROKER = 0;
 6 |   SERVER = 1;
 7 |   MHORDERER = 2;
 8 |   LOCALPAXOS = 3;
 9 |   GLOBALPAXOS = 4;
10 |   FORWARDER = 5;
11 |   SEQUENCER = 6;
12 |   INTERLEAVER = 7;
13 |   SCHEDULER = 8;
14 |   WORKER = 9;
15 | }


--------------------------------------------------------------------------------
/proto/offline_data.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto3";
2 | 
3 | package slog;
4 | 
5 | message Datum {
6 |     bytes key = 1;
7 |     bytes record = 2;
8 |     uint32 master = 3;
9 | }


--------------------------------------------------------------------------------
/proto/transaction.proto:
--------------------------------------------------------------------------------
  1 | syntax = "proto3";
  2 | package slog;
  3 | 
  4 | enum TransactionType {
  5 |     UNKNOWN = 0;
  6 |     SINGLE_HOME = 1;
  7 |     MULTI_HOME_OR_LOCK_ONLY = 2;
  8 | }
  9 | 
 10 | enum TransactionStatus {
 11 |     NOT_STARTED = 0;
 12 |     COMMITTED = 1;
 13 |     ABORTED = 2;
 14 | }
 15 | 
 16 | enum KeyType {
 17 |     READ = 0;
 18 |     WRITE = 1;
 19 | }
 20 | 
 21 | message MasterMetadata {
 22 |     uint32 master = 1;
 23 |     uint32 counter = 2;
 24 | }
 25 | 
 26 | message ValueEntry {
 27 |     bytes value = 1;
 28 |     bytes new_value = 2;
 29 |     KeyType type = 3;
 30 |     oneof optional {
 31 |         MasterMetadata metadata = 4;
 32 |     }
 33 | }
 34 | 
 35 | message KeyValueEntry {
 36 |     bytes key = 1;
 37 |     ValueEntry value_entry = 2;
 38 | }
 39 | 
 40 | enum TransactionEvent {
 41 |     ALL = 0; // Special value used to select all events
 42 |     ENTER_SERVER = 1;
 43 |     EXIT_SERVER_TO_FORWARDER = 2;
 44 |     ENTER_FORWARDER = 3;
 45 |     EXIT_FORWARDER_TO_SEQUENCER = 4;
 46 |     EXIT_FORWARDER_TO_MULTI_HOME_ORDERER = 5;
 47 |     ENTER_MULTI_HOME_ORDERER = 6;
 48 |     ENTER_MULTI_HOME_ORDERER_IN_BATCH = 7;
 49 |     EXIT_MULTI_HOME_ORDERER_IN_BATCH = 8;
 50 |     EXIT_MULTI_HOME_ORDERER = 9;
 51 |     ENTER_SEQUENCER = 10;
 52 |     ENTER_SEQUENCER_IN_BATCH = 11;
 53 |     EXIT_SEQUENCER_IN_BATCH = 12;
 54 |     ENTER_INTERLEAVER_IN_BATCH = 13;
 55 |     EXIT_INTERLEAVER = 14;
 56 |     ENTER_SCHEDULER = 15;
 57 |     ENTER_SCHEDULER_LO = 16;
 58 |     ENTER_LOCK_MANAGER = 17;
 59 |     DISPATCHED = 18;
 60 |     DISPATCHED_FAST = 19;
 61 |     DISPATCHED_SLOW = 20;
 62 |     ENTER_WORKER = 21;
 63 |     EXIT_WORKER = 22;
 64 |     RETURN_TO_SERVER = 23;
 65 |     EXIT_SERVER_TO_CLIENT = 24;
 66 | }
 67 | 
 68 | message TransactionEventInfo {
 69 |     // Event name
 70 |     TransactionEvent event = 1;
 71 |     // When the event took place
 72 |     int64 time = 2;
 73 |     // Where the event took place
 74 |     int32 machine = 3;
 75 |     // Home of the LockOnlyTxn when the event took place
 76 |     int32 home = 4;
 77 | }
 78 | 
 79 | message TransactionInternal {
 80 |     // unique transaction id, multi-home and lock only
 81 |     // txns share this id
 82 |     uint64 id = 1;
 83 |     TransactionType type = 2;
 84 |     int32 home = 3;
 85 |     uint32 coordinating_server = 4;
 86 |     int32 sequencer_delay_ms = 5;
 87 |     repeated uint32 involved_partitions = 6;
 88 |     repeated uint32 active_partitions = 7;
 89 |     repeated uint32 involved_replicas = 8;
 90 | 
 91 |     // for recording time of different events of txn
 92 |     repeated TransactionEventInfo events = 9;
 93 | 
 94 |     // positions in the global log
 95 |     repeated int64 global_log_positions = 10;
 96 | }
 97 | 
 98 | message RemasterProcedure {
 99 |     uint32 new_master = 1;
100 |     // The lock only for the new master will create a new key
101 |     bool is_new_master_lock_only = 2;
102 | }
103 | 
104 | message Procedure {
105 |     // First element is always the name of the procedure
106 |     repeated bytes args = 1;
107 | }
108 | 
109 | message Procedures {
110 |     repeated Procedure procedures = 1;
111 | }
112 | 
113 | message Transaction {
114 |     TransactionInternal internal = 1;
115 | 
116 |     oneof program {
117 |         /*
118 |         Procedures:
119 |         GET key1
120 |         SET key2 value2
121 |         DEL key4
122 |         COPY key1 key3
123 |         */
124 |         Procedures code = 2;
125 |         /*
126 |         Remaster transactions will move the keys in the write_set to the new master.
127 |         MasterMetadata must still be correct for the keys.
128 |         */
129 |         RemasterProcedure remaster = 3;
130 |     } 
131 | 
132 |     repeated KeyValueEntry keys = 4;
133 |     repeated bytes deleted_keys = 5;
134 | 
135 |     TransactionStatus status = 6;
136 |     string abort_reason = 7;
137 | }


--------------------------------------------------------------------------------
/service/service_utils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <gflags/gflags.h>
 4 | #include <glog/logging.h>
 5 | 
 6 | #include "google/protobuf/stubs/common.h"
 7 | namespace slog {
 8 | 
 9 | inline void InitializeService(int* argc, char*** argv) {
10 |   google::InitGoogleLogging((*argv)[0]);
11 |   google::InstallFailureSignalHandler();
12 |   google::ParseCommandLineFlags(argc, argv, true /* remove_flags */);
13 |   FLAGS_logtostderr = true;
14 |   FLAGS_colorlogtostderr = true;
15 |   // Verify that the version of the library that we linked against is
16 |   // compatible with the version of the headers we compiled against
17 |   GOOGLE_PROTOBUF_VERIFY_VERSION;
18 | }
19 | 
20 | }  // namespace slog


--------------------------------------------------------------------------------
/storage/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | target_sources(slog-core
2 |   PRIVATE
3 |     lookup_master_index.h
4 |     mem_only_storage.h
5 |     metadata_initializer.h
6 |     metadata_initializer.cpp
7 |     storage.h)


--------------------------------------------------------------------------------
/storage/lookup_master_index.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "common/types.h"
 4 | 
 5 | namespace slog {
 6 | 
 7 | class LookupMasterIndex {
 8 |  public:
 9 |   virtual bool GetMasterMetadata(const Key& key, Metadata& metadata) const = 0;
10 | };
11 | 
12 | }  // namespace slog


--------------------------------------------------------------------------------
/storage/mem_only_storage.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "data_structure/concurrent_hash_map.h"
 4 | #include "storage/lookup_master_index.h"
 5 | #include "storage/storage.h"
 6 | 
 7 | namespace slog {
 8 | 
 9 | class MemOnlyStorage : public Storage, public LookupMasterIndex {
10 |  public:
11 |   bool Read(const Key& key, Record& result) const final { return table_.Get(result, key); }
12 | 
13 |   bool Write(const Key& key, const Record& record) final { return table_.InsertOrUpdate(key, record); }
14 | 
15 |   bool Delete(const Key& key) final { return table_.Erase(key); }
16 | 
17 |   bool GetMasterMetadata(const Key& key, Metadata& metadata) const final {
18 |     Record rec;
19 |     if (!table_.Get(rec, key)) {
20 |       return false;
21 |     }
22 |     metadata = rec.metadata();
23 |     return true;
24 |   }
25 | 
26 |  private:
27 |   ConcurrentHashMap<Key, Record> table_;
28 | };
29 | 
30 | }  // namespace slog


--------------------------------------------------------------------------------
/storage/metadata_initializer.cpp:
--------------------------------------------------------------------------------
 1 | #include "storage/metadata_initializer.h"
 2 | 
 3 | namespace slog {
 4 | 
 5 | SimpleMetadataInitializer::SimpleMetadataInitializer(uint32_t num_replicas, uint32_t num_partitions)
 6 |     : num_replicas_(num_replicas), num_partitions_(num_partitions) {}
 7 | 
 8 | Metadata SimpleMetadataInitializer::Compute(const Key& key) {
 9 |   return Metadata((std::stoull(key) / num_partitions_) % num_replicas_);
10 | }
11 | 
12 | ConstantMetadataInitializer::ConstantMetadataInitializer(uint32_t home) : home_(home) {}
13 | 
14 | Metadata ConstantMetadataInitializer::Compute(const Key&) { return Metadata(home_); }
15 | 
16 | }  // namespace slog


--------------------------------------------------------------------------------
/storage/metadata_initializer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "common/types.h"
 4 | 
 5 | namespace slog {
 6 | 
 7 | class MetadataInitializer {
 8 |  public:
 9 |   virtual ~MetadataInitializer() = default;
10 |   virtual Metadata Compute(const Key& key) = 0;
11 | };
12 | 
13 | class SimpleMetadataInitializer : public MetadataInitializer {
14 |  public:
15 |   SimpleMetadataInitializer(uint32_t num_replicas, uint32_t num_partitions);
16 |   Metadata Compute(const Key& key) override;
17 | 
18 |  private:
19 |   uint32_t num_replicas_;
20 |   uint32_t num_partitions_;
21 | };
22 | 
23 | class ConstantMetadataInitializer : public MetadataInitializer {
24 |  public:
25 |   ConstantMetadataInitializer(uint32_t home);
26 |   Metadata Compute(const Key& key) override;
27 | 
28 |  private:
29 |   uint32_t home_;
30 | };
31 | 
32 | }  // namespace slog


--------------------------------------------------------------------------------
/storage/storage.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "common/types.h"
 4 | 
 5 | namespace slog {
 6 | 
 7 | class Storage {
 8 |  public:
 9 |   virtual ~Storage() = default;
10 |   virtual bool Read(const Key& key, Record& result) const = 0;
11 |   // Returns true if key exists
12 |   virtual bool Write(const Key& key, const Record& record) = 0;
13 |   virtual bool Write(const Key& key, Record&& record) { return Write(key, record); };
14 |   virtual bool Delete(const Key& key) = 0;
15 | };
16 | 
17 | }  // namespace slog


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | include(GoogleTest)
 2 | include(FetchContent)
 3 | 
 4 | FetchContent_Declare(googletest
 5 |   GIT_REPOSITORY https://github.com/google/googletest.git
 6 |   GIT_TAG        release-1.10.0
 7 | )
 8 | FetchContent_GetProperties(googletest)
 9 | if(NOT googletest_POPULATED)
10 |   message("Populating: googletest")
11 |   FetchContent_Populate(googletest)
12 |   add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
13 | endif()
14 | 
15 | add_library(test-utils test_utils.cpp)
16 | target_link_libraries(test-utils PUBLIC slog-core)
17 | 
18 | macro(add_slog_test TESTFILE)
19 |   get_filename_component(TESTNAME ${TESTFILE} NAME_WE)
20 |   add_executable(${TESTNAME} ${TESTFILE})
21 |   target_link_libraries(${TESTNAME} 
22 |     PRIVATE
23 |       gmock
24 |       gtest
25 |       gtest_main
26 |       test-utils)
27 |   gtest_discover_tests(${TESTNAME}
28 |     PROPERTIES 
29 |       RUN_SERIAL TRUE
30 |       TIMEOUT    5)
31 | endmacro()
32 | 
33 | add_slog_test(common/string_utils_test.cpp)
34 | add_slog_test(connection/broker_and_sender_test.cpp)
35 | add_slog_test(connection/zmq_utils_test.cpp)
36 | add_slog_test(data_structure/batch_log_test.cpp)
37 | add_slog_test(data_structure/concurrent_hash_map_test.cpp)
38 | add_slog_test(e2e/e2e_test.cpp)
39 | add_slog_test(execution/tpcc/table_test.cpp)
40 | add_slog_test(execution/tpcc/transaction_test.cpp)
41 | add_slog_test(module/forwarder_test.cpp)
42 | add_slog_test(module/interleaver_test.cpp)
43 | add_slog_test(module/scheduler_components/ddr_lock_manager_test.cpp)
44 | add_slog_test(module/scheduler_components/old_lock_manager_test.cpp)
45 | add_slog_test(module/scheduler_components/per_key_remaster_manager_test.cpp)
46 | add_slog_test(module/scheduler_components/rma_lock_manager_test.cpp)
47 | add_slog_test(module/scheduler_components/simple_remaster_manager_test.cpp)
48 | add_slog_test(module/scheduler_test.cpp)
49 | add_slog_test(module/sequencer_test.cpp)
50 | add_slog_test(paxos/paxos_test.cpp)
51 | add_slog_test(storage/mem_only_storage_test.cpp)


--------------------------------------------------------------------------------
/test/common/string_utils_test.cpp:
--------------------------------------------------------------------------------
 1 | #include "common/string_utils.h"
 2 | 
 3 | #include <gmock/gmock.h>
 4 | #include <gtest/gtest.h>
 5 | 
 6 | #include <iostream>
 7 | 
 8 | using namespace std;
 9 | using namespace slog;
10 | using namespace testing;
11 | 
12 | TEST(StringUtilsTest, NextTokenTest) {
13 |   string res;
14 | 
15 |   {
16 |     string str = "hello world, c++";
17 |     string delims = " ,";
18 |     auto pos = NextToken(res, str, delims);
19 |     ASSERT_EQ(res, "hello");
20 |     ASSERT_EQ(pos, 5U);
21 | 
22 |     pos = NextToken(res, str, delims, pos);
23 |     ASSERT_EQ(res, "world");
24 |     ASSERT_EQ(pos, 11U);
25 | 
26 |     pos = NextToken(res, str, delims, pos);
27 |     ASSERT_EQ(res, "c++");
28 |     ASSERT_EQ(pos, 16U);
29 | 
30 |     pos = NextToken(res, str, delims, pos);
31 |     ASSERT_EQ(res, "");
32 |     ASSERT_EQ(pos, string::npos);
33 |   }
34 | 
35 |   {
36 |     string str = "  hello  \t\t world !!! ";
37 |     string delims = " \t";
38 |     auto pos = NextToken(res, str, delims);
39 |     ASSERT_EQ(res, "hello");
40 |     ASSERT_EQ(pos, 7U);
41 | 
42 |     pos = NextToken(res, str, delims, pos);
43 |     ASSERT_EQ(res, "world");
44 |     ASSERT_EQ(pos, 17U);
45 | 
46 |     pos = NextToken(res, str, delims, pos);
47 |     ASSERT_EQ(res, "!!!");
48 |     ASSERT_EQ(pos, 21U);
49 | 
50 |     pos = NextToken(res, str, delims, pos);
51 |     ASSERT_EQ(res, "");
52 |     ASSERT_EQ(pos, string::npos);
53 |   }
54 | }
55 | 
56 | TEST(StringUtilsTest, NextNTokensTest) {
57 |   vector<string> res;
58 | 
59 |   {
60 |     string str = "this is   a   test  ";
61 |     string delims = " ";
62 |     auto pos = NextNTokens(res, str, delims, 3);
63 |     ASSERT_THAT(res, ElementsAre("this", "is", "a"));
64 |     ASSERT_EQ(pos, 11U);
65 | 
66 |     pos = NextNTokens(res, str, delims, 1, pos);
67 |     ASSERT_THAT(res, ElementsAre("test"));
68 |     ASSERT_EQ(pos, 18U);
69 | 
70 |     pos = NextNTokens(res, str, delims, 1, pos);
71 |     ASSERT_TRUE(res.empty());
72 |     ASSERT_EQ(pos, string::npos);
73 |   }
74 | 
75 |   {
76 |     string str = "  one \t two \t three  ";
77 |     string delims = " \t";
78 |     auto pos = NextNTokens(res, str, delims, 4);
79 |     ASSERT_TRUE(res.empty());
80 |     ASSERT_EQ(pos, string::npos);
81 |   }
82 | }
83 | 
84 | TEST(StringUtilsTest, TrimTest) {
85 |   ASSERT_EQ(Trim("       trim this plz    "), "trim this plz");
86 |   ASSERT_EQ(Trim(" \t\t trim this plz \t\t    "), "trim this plz");
87 | }


--------------------------------------------------------------------------------
/test/connection/zmq_utils_test.cpp:
--------------------------------------------------------------------------------
  1 | #include "connection/zmq_utils.h"
  2 | 
  3 | #include <gtest/gtest.h>
  4 | 
  5 | #include <iostream>
  6 | 
  7 | #include "proto/internal.pb.h"
  8 | 
  9 | using namespace std;
 10 | using namespace slog;
 11 | 
 12 | using internal::Request;
 13 | using internal::Response;
 14 | 
 15 | TEST(ZmqUtilsTest, SendAndReceiveProto) {
 16 |   zmq::context_t context(1);
 17 | 
 18 |   zmq::socket_t push(context, ZMQ_PUSH);
 19 |   push.bind("inproc://test");
 20 |   zmq::socket_t pull(context, ZMQ_PULL);
 21 |   pull.connect("inproc://test");
 22 | 
 23 |   Request req;
 24 |   req.mutable_ping()->set_time(99);
 25 |   SendSerializedProto(push, req);
 26 | 
 27 |   Request req2;
 28 |   ASSERT_TRUE(RecvDeserializedProto(pull, req2));
 29 |   ASSERT_EQ(req2.ping().time(), 99);
 30 | }
 31 | 
 32 | TEST(ZmqUtilsTest, SendAndReceiveProtoDealerRouter) {
 33 |   zmq::context_t context(1);
 34 | 
 35 |   zmq::socket_t router(context, ZMQ_ROUTER);
 36 |   router.bind("inproc://test");
 37 |   zmq::socket_t dealer(context, ZMQ_DEALER);
 38 |   dealer.connect("inproc://test");
 39 | 
 40 |   // First send from dealer and receive at router
 41 |   Request req;
 42 |   req.mutable_ping()->set_time(99);
 43 |   SendSerializedProtoWithEmptyDelim(dealer, req);
 44 | 
 45 |   zmq::message_t identity;
 46 |   (void)router.recv(identity);
 47 |   Request req2;
 48 |   ASSERT_TRUE(RecvDeserializedProtoWithEmptyDelim(router, req2));
 49 |   ASSERT_EQ(req2.ping().time(), 99);
 50 | 
 51 |   // Then send from router and receive at dealer
 52 |   req2.mutable_ping()->set_time(99);
 53 |   router.send(identity, zmq::send_flags::sndmore);
 54 |   SendSerializedProtoWithEmptyDelim(router, req2);
 55 | 
 56 |   ASSERT_TRUE(RecvDeserializedProtoWithEmptyDelim(dealer, req));
 57 |   ASSERT_EQ(req.ping().time(), 99);
 58 | }
 59 | 
 60 | TEST(ZmqUtilsTest, SendAndReceiveWrongProto) {
 61 |   zmq::context_t context(1);
 62 | 
 63 |   zmq::socket_t push(context, ZMQ_PUSH);
 64 |   push.bind("inproc://test");
 65 |   zmq::socket_t pull(context, ZMQ_PULL);
 66 |   pull.connect("inproc://test");
 67 | 
 68 |   Request req;
 69 |   req.mutable_ping()->set_time(99);
 70 |   SendSerializedProto(push, req);
 71 | 
 72 |   Response res;
 73 |   ASSERT_FALSE(RecvDeserializedProto(pull, res));
 74 | }
 75 | 
 76 | TEST(ZmqUtilsTest, ReceiveProtoDontWait) {
 77 |   zmq::context_t context(1);
 78 | 
 79 |   zmq::socket_t push(context, ZMQ_PUSH);
 80 |   push.bind("inproc://test");
 81 |   zmq::socket_t pull(context, ZMQ_PULL);
 82 |   pull.connect("inproc://test");
 83 | 
 84 |   Response res;
 85 |   ASSERT_FALSE(RecvDeserializedProto(pull, res, true));
 86 | }
 87 | 
 88 | TEST(ZmqUtilsTest, SendWithMachineIdAndChannel) {
 89 |   zmq::context_t context(1);
 90 | 
 91 |   zmq::socket_t push(context, ZMQ_PUSH);
 92 |   push.bind("inproc://test");
 93 |   zmq::socket_t pull(context, ZMQ_PULL);
 94 |   pull.connect("inproc://test");
 95 | 
 96 |   Request req;
 97 |   req.mutable_ping()->set_time(99);
 98 |   SendSerializedProto(push, req, 1, 9);
 99 | 
100 |   zmq::message_t msg;
101 |   (void)pull.recv(msg);
102 |   MachineId machineId;
103 |   ASSERT_TRUE(ParseMachineId(machineId, msg));
104 |   ASSERT_EQ(machineId, 1);
105 | 
106 |   Channel channel;
107 |   ASSERT_TRUE(ParseChannel(channel, msg));
108 |   ASSERT_EQ(channel, 9);
109 | }
110 | 
111 | TEST(ZmqUtilsTest, FailedParsing) {
112 |   zmq::message_t msg;
113 |   MachineId id;
114 |   ASSERT_FALSE(ParseMachineId(id, msg));
115 |   Channel chan;
116 |   ASSERT_FALSE(ParseChannel(chan, msg));
117 |   Request req;
118 |   ASSERT_FALSE(DeserializeProto(req, msg));
119 | }


--------------------------------------------------------------------------------
/test/data_structure/batch_log_test.cpp:
--------------------------------------------------------------------------------
 1 | #include "data_structure/batch_log.h"
 2 | 
 3 | #include <gtest/gtest.h>
 4 | 
 5 | using namespace std;
 6 | using namespace slog;
 7 | 
 8 | using internal::Batch;
 9 | 
10 | class BatchLogTest : public ::testing::Test {
11 |  protected:
12 |   static const size_t NUM_BATCHES = 3;
13 | 
14 |   void SetUp() {
15 |     for (size_t i = 0; i < NUM_BATCHES; i++) {
16 |       batches[i] = make_unique<Batch>();
17 |       batches[i]->set_id(100 * (i + 1));
18 |     }
19 |   }
20 | 
21 |   bool BatchEQ(pair<uint32_t, uint32_t> expected_id, pair<SlotId, BatchPtr> batch) {
22 |     return batch.second != nullptr && expected_id.second == batch.second->id() && expected_id.first == batch.first;
23 |   }
24 | 
25 |   BatchPtr batches[NUM_BATCHES];  // batch ids: 100 200 300
26 | };
27 | 
28 | TEST_F(BatchLogTest, InOrder) {
29 |   BatchLog log;
30 |   log.AddSlot(0 /* slot_id */, 100 /* batch_id */);
31 |   log.AddBatch(move(batches[0]));
32 |   ASSERT_TRUE(BatchEQ({0, 100}, log.NextBatch()));
33 | 
34 |   log.AddSlot(1 /* slot_id */, 200 /* batch_id */);
35 |   log.AddBatch(move(batches[1]));
36 |   ASSERT_TRUE(BatchEQ({1, 200}, log.NextBatch()));
37 | 
38 |   log.AddSlot(2 /* slot_id */, 300 /* batch_id */);
39 |   log.AddBatch(move(batches[2]));
40 |   ASSERT_TRUE(BatchEQ({2, 300}, log.NextBatch()));
41 | 
42 |   ASSERT_FALSE(log.HasNextBatch());
43 | }
44 | 
45 | TEST_F(BatchLogTest, OutOfOrder) {
46 |   BatchLog log;
47 |   log.AddBatch(move(batches[1]));
48 |   ASSERT_FALSE(log.HasNextBatch());
49 | 
50 |   log.AddBatch(move(batches[0]));
51 |   ASSERT_FALSE(log.HasNextBatch());
52 | 
53 |   log.AddSlot(1 /* slot_id */, 100 /* batch_id */);
54 |   ASSERT_FALSE(log.HasNextBatch());
55 | 
56 |   log.AddSlot(0 /* slot_id */, 200 /* batch_id */);
57 |   ASSERT_TRUE(BatchEQ({0, 200}, log.NextBatch()));
58 |   ASSERT_TRUE(BatchEQ({1, 100}, log.NextBatch()));
59 | 
60 |   ASSERT_FALSE(log.HasNextBatch());
61 | }
62 | 
63 | TEST_F(BatchLogTest, MultipleNextBatches) {
64 |   BatchLog log;
65 | 
66 |   log.AddBatch(move(batches[2]));
67 |   log.AddBatch(move(batches[1]));
68 |   log.AddBatch(move(batches[0]));
69 |   log.AddSlot(2 /* slot_id */, 300 /* batch_id */);
70 |   log.AddSlot(1 /* slot_id */, 200 /* batch_id */);
71 |   log.AddSlot(0 /* slot_id */, 100 /* batch_id */);
72 | 
73 |   ASSERT_TRUE(BatchEQ({0, 100}, log.NextBatch()));
74 |   ASSERT_TRUE(BatchEQ({1, 200}, log.NextBatch()));
75 |   ASSERT_TRUE(BatchEQ({2, 300}, log.NextBatch()));
76 |   ASSERT_FALSE(log.HasNextBatch());
77 | }


--------------------------------------------------------------------------------
/test/data_structure/concurrent_hash_map_test.cpp:
--------------------------------------------------------------------------------
  1 | #include "data_structure/concurrent_hash_map.h"
  2 | 
  3 | #include <gtest/gtest.h>
  4 | 
  5 | #include <thread>
  6 | 
  7 | using namespace std;
  8 | using namespace slog;
  9 | 
 10 | TEST(ConcurrentHashMapTest, SerialBasicOperations) {
 11 |   ConcurrentHashMap<string, string> map;
 12 |   string result;
 13 |   ASSERT_FALSE(map.Get(result, "test"));
 14 |   ASSERT_FALSE(map.Erase("test"));
 15 | 
 16 |   for (size_t i = 0; i < 10; i++) {
 17 |     ASSERT_FALSE(map.InsertOrUpdate(to_string(i), "foo"));
 18 |   }
 19 |   for (size_t i = 0; i < 10; i++) {
 20 |     ASSERT_TRUE(map.Get(result, to_string(i)));
 21 |     ASSERT_EQ(result, "foo");
 22 |   }
 23 |   for (size_t i = 0; i < 10; i++) {
 24 |     auto val = map.GetUnsafe(to_string(i));
 25 |     ASSERT_NE(val, nullptr);
 26 |     ASSERT_EQ(*val, "foo");
 27 |   }
 28 |   ASSERT_TRUE(map.InsertOrUpdate("0", "bar"));
 29 |   ASSERT_TRUE(map.Get(result, "0"));
 30 |   ASSERT_EQ(result, "bar");
 31 | 
 32 |   for (size_t i = 0; i < 10; i++) {
 33 |     ASSERT_TRUE(map.Erase(to_string(i)));
 34 |   }
 35 |   for (size_t i = 0; i < 10; i++) {
 36 |     ASSERT_FALSE(map.Get(result, to_string(i)));
 37 |     ASSERT_EQ(map.GetUnsafe(to_string(i)), nullptr);
 38 |   }
 39 | }
 40 | 
 41 | TEST(ConcurrentHashMapTest, TriggerRehash) {
 42 |   ConcurrentHashMap<string, string> map;
 43 |   string result;
 44 | 
 45 |   for (size_t i = 0; i < 10000; i++) {
 46 |     ASSERT_FALSE(map.InsertOrUpdate(to_string(i), "foo" + to_string(i)));
 47 |   }
 48 | 
 49 |   for (size_t i = 0; i < 10000; i++) {
 50 |     ASSERT_TRUE(map.Get(result, to_string(i))) << "Failed at i = " << i;
 51 |     ASSERT_EQ(result, "foo" + to_string(i)) << "Failed at i = " << i;
 52 |   }
 53 | 
 54 |   for (size_t i = 0; i < 10000; i++) {
 55 |     ASSERT_TRUE(map.Erase(to_string(i)));
 56 |   }
 57 | 
 58 |   for (size_t i = 0; i < 10000; i++) {
 59 |     ASSERT_FALSE(map.Get(result, to_string(i)));
 60 |   }
 61 | }
 62 | 
 63 | TEST(ConcurrentHashMapTest, TwoReadersOneWriter) {
 64 |   uint32_t N = 500000;
 65 |   string key = "foo";
 66 |   ConcurrentHashMap<string, string> map;
 67 | 
 68 |   auto Updates = [&]() {
 69 |     for (size_t i = 0; i < N; i++) {
 70 |       map.InsertOrUpdate(key, to_string(i));
 71 |     }
 72 |   };
 73 | 
 74 |   auto Gets = [&]() {
 75 |     int prev = 0;
 76 |     string result;
 77 |     for (size_t i = 0; i < N; i++) {
 78 |       if (map.Get(result, key)) {
 79 |         auto x = stoi(result);
 80 |         ASSERT_GE(x, prev);
 81 |         prev = x;
 82 |       }
 83 |     }
 84 |   };
 85 | 
 86 |   thread w(Updates);
 87 |   thread r1(Gets);
 88 |   thread r2(Gets);
 89 |   w.join();
 90 |   r1.join();
 91 |   r2.join();
 92 | }
 93 | 
 94 | TEST(ConcurrentHashMapTest, TwoWritersDifferentKeys) {
 95 |   int N = 500000;
 96 |   ConcurrentHashMap<string, string> map;
 97 | 
 98 |   auto Updates = [&](int start) {
 99 |     for (int i = start; i < N; i += 2) {
100 |       map.InsertOrUpdate(to_string(i), to_string(i));
101 |     }
102 |   };
103 | 
104 |   thread w1(Updates, 0);
105 |   thread w2(Updates, 1);
106 |   w1.join();
107 |   w2.join();
108 | 
109 |   string result;
110 |   for (int i = 0; i < N; i++) {
111 |     ASSERT_TRUE(map.Get(result, to_string(i)));
112 |     ASSERT_EQ(result, to_string(i));
113 |   }
114 | }
115 | 
116 | TEST(ConcurrentHashMapTest, TwoWritersSameKey) {
117 |   int N = 500000;
118 |   string key = "foo";
119 |   ConcurrentHashMap<string, string> map;
120 | 
121 |   auto Updates = [&]() {
122 |     for (int i = 0; i < N; i += 1) {
123 |       map.InsertOrUpdate(key, to_string(i));
124 |     }
125 |   };
126 | 
127 |   thread w1(Updates);
128 |   thread w2(Updates);
129 |   w1.join();
130 |   w2.join();
131 | 
132 |   string result;
133 |   ASSERT_TRUE(map.Get(result, key));
134 |   ASSERT_EQ(result, to_string(N - 1));
135 | }
136 | 
137 | TEST(ConcurrentHashMapTest, OneWriterOneEraser) {
138 |   int N = 100000;
139 |   ConcurrentHashMap<string, string> map;
140 | 
141 |   auto Updates = [&]() {
142 |     for (int i = 0; i < N; i++) {
143 |       map.InsertOrUpdate(to_string(i), to_string(i));
144 |     }
145 |   };
146 | 
147 |   auto Erases = [&]() {
148 |     for (int i = 0; i < N; i++) {
149 |       map.Erase(to_string(i));
150 |     }
151 |   };
152 | 
153 |   thread w1(Updates);
154 |   thread w2(Erases);
155 |   w1.join();
156 |   w2.join();
157 | 
158 |   string result;
159 |   for (int i = 0; i < N; i++) {
160 |     if (map.Get(result, to_string(i))) {
161 |       ASSERT_EQ(result, to_string(i));
162 |     }
163 |   }
164 | }


--------------------------------------------------------------------------------
/test/storage/mem_only_storage_test.cpp:
--------------------------------------------------------------------------------
 1 | #include "storage/mem_only_storage.h"
 2 | 
 3 | #include <gtest/gtest.h>
 4 | 
 5 | #include "common/types.h"
 6 | 
 7 | using namespace slog;
 8 | 
 9 | TEST(MemOnlyStorageTest, ReadWriteTest) {
10 |   MemOnlyStorage storage;
11 |   Key key = "key1";
12 |   Value value = "value1";
13 |   Record record(value, 0);
14 |   storage.Write(key, record);
15 | 
16 |   Record ret;
17 |   bool ok = storage.Read(key, ret);
18 |   ASSERT_TRUE(ok);
19 |   ASSERT_EQ(value, ret.to_string());
20 | }


--------------------------------------------------------------------------------
/test/test_utils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <glog/logging.h>
 4 | 
 5 | #include <optional>
 6 | #include <unordered_set>
 7 | #include <vector>
 8 | 
 9 | #include "common/configuration.h"
10 | #include "connection/broker.h"
11 | #include "connection/sender.h"
12 | #include "connection/zmq_utils.h"
13 | #include "module/base/module.h"
14 | #include "module/scheduler_components/txn_holder.h"
15 | #include "proto/internal.pb.h"
16 | #include "storage/mem_only_storage.h"
17 | #include "storage/metadata_initializer.h"
18 | 
19 | using std::pair;
20 | using std::shared_ptr;
21 | using std::string;
22 | using std::unique_ptr;
23 | namespace slog {
24 | 
25 | const auto kTestModuleTimeout = std::chrono::milliseconds(5);
26 | 
27 | using ConfigVec = std::vector<ConfigurationPtr>;
28 | 
29 | ConfigVec MakeTestConfigurations(string&& prefix, int num_replicas, int num_partitions,
30 |                                  internal::Configuration common_config = {});
31 | 
32 | Transaction* MakeTestTransaction(const ConfigurationPtr& config, TxnId id, const std::vector<KeyMetadata>& keys,
33 |                                  const std::vector<std::vector<std::string>> code = {{}},
34 |                                  std::optional<int> remaster = std::nullopt, MachineId coordinator = 0);
35 | 
36 | TxnHolder MakeTestTxnHolder(const ConfigurationPtr& config, TxnId id, const std::vector<KeyMetadata>& keys,
37 |                             const std::vector<std::vector<std::string>> code = {{}},
38 |                             std::optional<int> remaster = std::nullopt);
39 | 
40 | ValueEntry TxnValueEntry(const Transaction& txn, const std::string& key);
41 | 
42 | using ModuleRunnerPtr = unique_ptr<ModuleRunner>;
43 | 
44 | /**
45 |  * This is a fake SLOG system where we can only add a subset
46 |  * of modules to test them in isolation.
47 |  */
48 | class TestSlog {
49 |  public:
50 |   TestSlog(const ConfigurationPtr& config);
51 |   void Data(Key&& key, Record&& record);
52 |   void AddServerAndClient();
53 |   void AddForwarder();
54 |   void AddSequencer();
55 |   void AddInterleaver();
56 |   void AddScheduler();
57 |   void AddLocalPaxos();
58 |   void AddGlobalPaxos();
59 |   void AddMultiHomeOrderer();
60 | 
61 |   void AddOutputSocket(Channel channel);
62 |   zmq::pollitem_t GetPollItemForOutputSocket(Channel channel, bool inproc = true);
63 |   EnvelopePtr ReceiveFromOutputSocket(Channel channel, bool inproc = true);
64 | 
65 |   unique_ptr<Sender> NewSender();
66 | 
67 |   void StartInNewThreads();
68 |   void SendTxn(Transaction* txn);
69 |   Transaction RecvTxnResult();
70 | 
71 |   const ConfigurationPtr& config() const { return config_; }
72 |   const SharderPtr& sharder() const { return sharder_; }
73 |   const std::shared_ptr<MetadataInitializer>& metadata_initializer() const { return metadata_initializer_; }
74 | 
75 |  private:
76 |   ConfigurationPtr config_;
77 |   SharderPtr sharder_;
78 |   shared_ptr<MemOnlyStorage> storage_;
79 |   shared_ptr<MetadataInitializer> metadata_initializer_;
80 |   shared_ptr<Broker> broker_;
81 |   ModuleRunnerPtr server_;
82 |   ModuleRunnerPtr forwarder_;
83 |   ModuleRunnerPtr sequencer_;
84 |   ModuleRunnerPtr interleaver_;
85 |   ModuleRunnerPtr scheduler_;
86 |   ModuleRunnerPtr local_paxos_;
87 |   ModuleRunnerPtr global_paxos_;
88 |   ModuleRunnerPtr multi_home_orderer_;
89 | 
90 |   std::unordered_map<Channel, zmq::socket_t> inproc_sockets_;
91 |   std::unordered_map<Channel, zmq::socket_t> outproc_sockets_;
92 | 
93 |   zmq::context_t client_context_;
94 |   zmq::socket_t client_socket_;
95 | };
96 | 
97 | }  // namespace slog


--------------------------------------------------------------------------------
/tools/aws/spot_cluster_config_template.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "default": {
 3 |         "IamFleetRole": "<arn-of-aws-ec2-spot-fleet-tagging-role>",
 4 |         "AllocationStrategy": "capacityOptimized",
 5 |         "TargetCapacity": 6,
 6 |         "TerminateInstancesWithExpiration": true,
 7 |         "Type": "request"
 8 |     },
 9 |     "us-east-1": {
10 |         "LaunchSpecifications": [
11 |             {
12 |                 "ImageId": "ami-...",
13 |                 "InstanceType": "m2.4xlarge",
14 |                 "KeyName": "slog",
15 |                 "SecurityGroups": [
16 |                     {
17 |                         "GroupId": "sg-..."
18 |                     }
19 |                 ]
20 |             },
21 |             {
22 |                 "ImageId": "ami-...",
23 |                 "InstanceType": "r3.2xlarge",
24 |                 "KeyName": "slog",
25 |                 "SecurityGroups": [
26 |                     {
27 |                         "GroupId": "sg-..."
28 |                     }
29 |                 ]
30 |             }
31 |         ]
32 |     },
33 |     "us-east-2": {
34 |         "LaunchSpecifications": [
35 |             {
36 |                 "ImageId": "ami-...",
37 |                 "InstanceType": "r3.2xlarge",
38 |                 "KeyName": "slog",
39 |                 "SecurityGroups": [
40 |                     {
41 |                         "GroupId": "sg-..."
42 |                     }
43 |                 ]
44 |             },
45 |             {
46 |                 "ImageId": "ami-...",
47 |                 "InstanceType": "r4.2xlarge",
48 |                 "KeyName": "slog",
49 |                 "SecurityGroups": [
50 |                     {
51 |                         "GroupId": "sg-..."
52 |                     }
53 |                 ]
54 |             }
55 |         ]
56 |     }
57 | }


--------------------------------------------------------------------------------
/tools/common.py:
--------------------------------------------------------------------------------
 1 | import argparse
 2 | import logging
 3 | 
 4 | LOG_FORMAT = "%(asctime)s %(name)10s %(levelname)s: %(message)s"
 5 | logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)
 6 | 
 7 | class Command:
 8 |     """Base class for a command"""
 9 | 
10 |     NAME = "<not_implemented>"
11 |     HELP = ""
12 |     DESCRIPTION = ""
13 | 
14 |     def create_subparser(self, subparsers):
15 |         parser = subparsers.add_parser(
16 |             self.NAME, description=self.DESCRIPTION, help=self.HELP)
17 |         parser.set_defaults(run=self.initialize_and_do_command)
18 |         self.add_arguments(parser)
19 |         return parser
20 | 
21 |     def add_arguments(self, parser):
22 |         pass
23 | 
24 |     def initialize_and_do_command(self, args):
25 |         pass
26 | 
27 | 
28 | def initialize_and_run_commands(description, commands):
29 |     parser = argparse.ArgumentParser(description=description)
30 |     subparsers = parser.add_subparsers(dest="command name")
31 |     subparsers.required = True
32 | 
33 |     for command in commands:
34 |         command().create_subparser(subparsers)
35 | 
36 |     args = parser.parse_args()
37 |     args.run(args)


--------------------------------------------------------------------------------
/tools/deinterleave.py:
--------------------------------------------------------------------------------
 1 | """Group output of gtest by thread id
 2 | 
 3 | Example usage:
 4 | 
 5 | > python3 tools/deinterleave.py <<EOF  
 6 | I1226 06:33:06.426666 11224 broker.cpp:113] Bound Broker to: ipc:///tmp/test_e2e0
 7 | I1226 06:33:06.427703 11224 broker.cpp:133] Sent READY message to ipc:///tmp/test_e2e0
 8 | I1226 06:33:06.447345 11232 broker.cpp:113] Bound Broker to: ipc:///tmp/test_e2e1
 9 | I1226 06:33:06.447707 11232 broker.cpp:133] Sent READY message to ipc:///tmp/test_e2e0
10 | I1226 06:33:06.447993 11232 broker.cpp:133] Sent READY message to ipc:///tmp/test_e2e1
11 | I1226 06:33:06.448770 11232 broker.cpp:146] Waiting for READY messages from other machines...
12 | I1226 06:33:06.448783 11232 broker.cpp:172] Received READY message from /tmp/test_e2e1 (rep: 0, part: 1)
13 | I1226 06:33:06.449044 11232 broker.cpp:172] Received READY message from /tmp/test_e2e0 (rep: 0, part: 0)
14 | I1226 06:33:06.449077 11224 broker.cpp:133] Sent READY message to ipc:///tmp/test_e2e1
15 | I1226 06:33:06.449609 11224 broker.cpp:146] Waiting for READY messages from other machines...
16 | I1226 06:33:06.449635 11224 broker.cpp:172] Received READY message from /tmp/test_e2e0 (rep: 0, part: 0)
17 | I1226 06:33:06.449654 11224 broker.cpp:172] Received READY message from /tmp/test_e2e1 (rep: 0, part: 1)
18 | I1226 06:33:06.450145 11232 broker.cpp:181] All READY messages received
19 | I1226 06:33:06.450448 11224 broker.cpp:181] All READY messages received
20 | EOF
21 | 
22 | ========================================================================================================
23 | Thread "11224"
24 | I1226 06:33:06.426666 11224 broker.cpp:113] Bound Broker to: ipc:///tmp/test_e2e0
25 | I1226 06:33:06.427703 11224 broker.cpp:133] Sent READY message to ipc:///tmp/test_e2e0
26 | I1226 06:33:06.449077 11224 broker.cpp:133] Sent READY message to ipc:///tmp/test_e2e1
27 | I1226 06:33:06.449609 11224 broker.cpp:146] Waiting for READY messages from other machines...
28 | I1226 06:33:06.449635 11224 broker.cpp:172] Received READY message from /tmp/test_e2e0 (rep: 0, part: 0)
29 | I1226 06:33:06.449654 11224 broker.cpp:172] Received READY message from /tmp/test_e2e1 (rep: 0, part: 1)
30 | I1226 06:33:06.450448 11224 broker.cpp:181] All READY messages received
31 | 
32 | Thread "11232"
33 | I1226 06:33:06.447345 11232 broker.cpp:113] Bound Broker to: ipc:///tmp/test_e2e1
34 | I1226 06:33:06.447707 11232 broker.cpp:133] Sent READY message to ipc:///tmp/test_e2e0
35 | I1226 06:33:06.447993 11232 broker.cpp:133] Sent READY message to ipc:///tmp/test_e2e1
36 | I1226 06:33:06.448770 11232 broker.cpp:146] Waiting for READY messages from other machines...
37 | I1226 06:33:06.448783 11232 broker.cpp:172] Received READY message from /tmp/test_e2e1 (rep: 0, part: 1)
38 | I1226 06:33:06.449044 11232 broker.cpp:172] Received READY message from /tmp/test_e2e0 (rep: 0, part: 0)
39 | I1226 06:33:06.450145 11232 broker.cpp:181] All READY messages received
40 | """
41 | import re
42 | import sys
43 | 
44 | logs_per_thread = {}
45 | max_len = 10
46 | for line in sys.stdin:
47 |     log = line.strip()
48 |     max_len = max(max_len, len(log))
49 |     tokens = re.split('\s+', log)
50 |     if len(tokens) > 3:
51 |         thread_id = tokens[2]
52 |         logs_per_thread.setdefault(thread_id, []).append(log)
53 | 
54 | print()
55 | print('='*max_len)
56 | for thread_id in logs_per_thread:
57 |     print(f'Thread "{thread_id}"')
58 |     for log in logs_per_thread[thread_id]:
59 |         print(log)
60 |     print()
61 | 
62 | 


--------------------------------------------------------------------------------
/tools/fnv_hash.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python3
 2 | import sys
 3 | if sys.version_info[0] == 3:
 4 |     _get_byte = lambda c: c
 5 | else:
 6 |     _get_byte = ord
 7 | 
 8 | from argparse import ArgumentParser
 9 | 
10 | 
11 | def fnv_hash(value: bytes, num_bytes: int) -> int:
12 |     assert isinstance(value, bytes)
13 | 
14 |     if num_bytes <= 0: num_bytes = len(value)
15 | 
16 |     FNV_32_PRIME = 0x01000193
17 |     FNV_32_SIZE = 2**32
18 | 
19 |     hash = 0x811c9dc5
20 |     for byte in value[:num_bytes]:
21 |         hash = (hash * FNV_32_PRIME) % FNV_32_SIZE
22 |         hash = hash ^ _get_byte(byte)
23 |     return hash
24 | 
25 | 
26 | if __name__ == "__main__":
27 |     parser = ArgumentParser(
28 |         description="Computes FNV hash for a given string"
29 |     )
30 |     parser.add_argument("string", help="A string to compute FNV hash")
31 |     parser.add_argument(
32 |         "-m",
33 |         type=int,
34 |         help="The result will be taken modulo by this value."
35 |     )
36 |     parser.add_argument(
37 |         "-b",
38 |         type=int,
39 |         default=0,
40 |         help="Number of prefix bytes used to compute the hash. "
41 |              "Set to 0 (default) to use the whole value."
42 |     )
43 |     args = parser.parse_args()
44 |     result = fnv_hash(args.string.encode(), args.b)
45 |     if args.m is not None:
46 |         result %= args.m
47 |     print(result)


--------------------------------------------------------------------------------
/tools/microbenchmark.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #
 3 | # Usage:
 4 | #   -a  Path to the admin tool
 5 | #   -c  Path to the config file
 6 | #   -i  Docker image name
 7 | #   -o  Output directory
 8 | #   -u  Username used to SSH to the remote machines
 9 | #
10 | # Example:
11 | #
12 | # tools/microbenchmark.sh\
13 | #  -a tools/admin.py\
14 | #  -c ~/configs/slog/slog.conf\
15 | #  -i ctring/slog:rma-master\
16 | #  -o ~/data/slog
17 | #
18 | 
19 | BENCHMARK_ARGS="--clients 200 --generators 5 --txns 500000 --duration 30 --sample 10"
20 | 
21 | USER="ubuntu"
22 | PREFIX="slog"
23 | OUT_DIR="."
24 | TRIALS=1
25 | 
26 | while getopts a:c:i:o:p:u: flag
27 | do
28 |   case "${flag}" in
29 |     a) ADMIN_TOOL=${OPTARG};;
30 |     c) CONFIG=${OPTARG};;
31 |     i) IMAGE=${OPTARG};;
32 |     o) OUT_DIR=${OPTARG};;
33 |     u) USER=${OPTARG};;
34 |     p) PREFIX=${OPTARG};;
35 |     t) TRIALS=${OPTARG};;
36 |   esac
37 | done
38 | 
39 | if [[ -z $ADMIN_TOOL ]]; then
40 |   echo "ERROR: Use the -a flag to specify the admin tool"
41 |   exit 1
42 | fi
43 | 
44 | if [[ -z $CONFIG ]]; then
45 |   echo "ERROR: Use the -c flag to specify the config file"
46 |   exit 1
47 | fi
48 | 
49 | 
50 | if [[ -z $IMAGE ]]; then
51 |   echo "ERROR: Use the -i flag to specify the Docker image"
52 |   exit 1
53 | fi
54 | 
55 | set -x
56 | 
57 | function run_benchmark {
58 |   HOT=$1
59 |   MH=$2
60 |   MP=$3
61 |   TAG=${PREFIX}-hot${HOT}mh${MH}mp${MP}
62 |   
63 |   for i in $(seq 1 ${TRIALS})
64 |   do
65 |     if [ $TRIALS -gt 1 ]; then
66 |       NTAG=${TAG}-${i}
67 |     else
68 |       NTAG=${TAG}
69 |     fi
70 |     python3 ${ADMIN_TOOL} benchmark ${CONFIG} ${BENCHMARK_ARGS} --image ${IMAGE} -u ${USER} --params "writes=10,records=10,hot=$HOT,hot_records=2,mh=$MH,mp=$MP" --tag ${NTAG}
71 |     python3 ${ADMIN_TOOL} collect_client --out-dir ${OUT_DIR} -u ${USER} ${CONFIG} ${NTAG}
72 |     # For debug only
73 |     # python3 ${ADMIN_TOOL} collect_server --out-dir ${OUT_DIR} -u ${USER} --image ${IMAGE} ${CONFIG} --tag ${NTAG}
74 |   done
75 | }
76 | 
77 | run_benchmark 10000 0 0
78 | run_benchmark 10000 50 0
79 | run_benchmark 10000 100 0
80 | run_benchmark 10000 0 50
81 | run_benchmark 10000 50 50
82 | run_benchmark 10000 100 50
83 | run_benchmark 10000 0 100
84 | run_benchmark 10000 50 100
85 | run_benchmark 10000 100 100
86 | run_benchmark 30 0 0
87 | run_benchmark 30 50 0
88 | run_benchmark 30 100 0
89 | run_benchmark 30 0 50
90 | run_benchmark 30 50 50
91 | run_benchmark 30 100 50
92 | run_benchmark 30 0 100
93 | run_benchmark 30 50 100
94 | run_benchmark 30 100 100
95 | 


--------------------------------------------------------------------------------
/tools/netem.py:
--------------------------------------------------------------------------------
 1 | import argparse
 2 | 
 3 | def gen_netem_script(netems, dev, filters):
 4 |     '''Generates a tc netem script
 5 | 
 6 |     netems  a list of arguments for netem qdiscs
 7 |     dev     dev argument of 'tc'
 8 |     filters a list with the same size as 'netems'. Each element is a list of
 9 |             IP addresses that will be filtered and queued to the corresponding qdisc
10 |     '''
11 |     assert len(netems) == len(filters), "Number of filter groups must match number of netem argument groups"
12 | 
13 |     script = [
14 |         "# Generated by netem.py",
15 |         "set +e",
16 |         f"tc qdisc del dev {dev} root 2> /dev/null",
17 |         "set -ex",
18 |         f"tc qdisc add dev {dev} root handle 1: htb"
19 |     ]
20 | 
21 |     for i, netem in enumerate(netems):
22 |         script += [
23 |             f"tc class add dev {dev} parent 1: classid 1:{i+1} htb rate 1gbit",
24 |             f"tc qdisc add dev {dev} parent 1:{i+1} handle {(i+1)*10}: netem {netem}",
25 |         ]
26 |     for i, filter in enumerate(filters):
27 |         for ip in filter:
28 |             script += [
29 |                f"tc filter add dev {dev} parent 1: protocol ip prio 1 u32 match ip dst {ip} flowid 1:{i+1}"
30 |             ]
31 |     script += [
32 |         'set +x',
33 |         'echo',
34 |         'echo "***** QDISC ******"',
35 |         f'tc -col qdisc show dev {dev}',
36 |         'echo',
37 |         'echo "***** CLASS ******"',
38 |         f'tc -col class show dev {dev}',
39 |         'echo',
40 |         'echo "***** FILTER ******"',
41 |         f'tc -col filter show dev {dev}',
42 |         'echo',
43 |     ]
44 |     return '\n'.join(script)
45 | 
46 | 
47 | if __name__ == '__main__':
48 |     parser = argparse.ArgumentParser(description="Generate netem script")
49 |     parser.add_argument("netem", help="Netem commands")
50 |     parser.add_argument("-d", "--dev", default="eth0", help="Network interface to apply on")
51 |     parser.add_argument("-f", "--filter", nargs="*", help="IP addresses to apply on")
52 | 
53 |     args = parser.parse_args()
54 |     if args.filter is None:
55 |         args.filter = []
56 |     print(gen_netem_script([args.netem], args.dev, [args.filter]))
57 | 


--------------------------------------------------------------------------------
/tools/proto/modules_pb2.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # Generated by the protocol buffer compiler.  DO NOT EDIT!
  3 | # source: proto/modules.proto
  4 | """Generated protocol buffer code."""
  5 | from google.protobuf.internal import enum_type_wrapper
  6 | from google.protobuf import descriptor as _descriptor
  7 | from google.protobuf import message as _message
  8 | from google.protobuf import reflection as _reflection
  9 | from google.protobuf import symbol_database as _symbol_database
 10 | # @@protoc_insertion_point(imports)
 11 | 
 12 | _sym_db = _symbol_database.Default()
 13 | 
 14 | 
 15 | 
 16 | 
 17 | DESCRIPTOR = _descriptor.FileDescriptor(
 18 |   name='proto/modules.proto',
 19 |   package='slog',
 20 |   syntax='proto3',
 21 |   serialized_options=None,
 22 |   create_key=_descriptor._internal_create_key,
 23 |   serialized_pb=b'\n\x13proto/modules.proto\x12\x04slog*\x9c\x01\n\x08ModuleId\x12\n\n\x06\x42ROKER\x10\x00\x12\n\n\x06SERVER\x10\x01\x12\r\n\tMHORDERER\x10\x02\x12\x0e\n\nLOCALPAXOS\x10\x03\x12\x0f\n\x0bGLOBALPAXOS\x10\x04\x12\r\n\tFORWARDER\x10\x05\x12\r\n\tSEQUENCER\x10\x06\x12\x0f\n\x0bINTERLEAVER\x10\x07\x12\r\n\tSCHEDULER\x10\x08\x12\n\n\x06WORKER\x10\tb\x06proto3'
 24 | )
 25 | 
 26 | _MODULEID = _descriptor.EnumDescriptor(
 27 |   name='ModuleId',
 28 |   full_name='slog.ModuleId',
 29 |   filename=None,
 30 |   file=DESCRIPTOR,
 31 |   create_key=_descriptor._internal_create_key,
 32 |   values=[
 33 |     _descriptor.EnumValueDescriptor(
 34 |       name='BROKER', index=0, number=0,
 35 |       serialized_options=None,
 36 |       type=None,
 37 |       create_key=_descriptor._internal_create_key),
 38 |     _descriptor.EnumValueDescriptor(
 39 |       name='SERVER', index=1, number=1,
 40 |       serialized_options=None,
 41 |       type=None,
 42 |       create_key=_descriptor._internal_create_key),
 43 |     _descriptor.EnumValueDescriptor(
 44 |       name='MHORDERER', index=2, number=2,
 45 |       serialized_options=None,
 46 |       type=None,
 47 |       create_key=_descriptor._internal_create_key),
 48 |     _descriptor.EnumValueDescriptor(
 49 |       name='LOCALPAXOS', index=3, number=3,
 50 |       serialized_options=None,
 51 |       type=None,
 52 |       create_key=_descriptor._internal_create_key),
 53 |     _descriptor.EnumValueDescriptor(
 54 |       name='GLOBALPAXOS', index=4, number=4,
 55 |       serialized_options=None,
 56 |       type=None,
 57 |       create_key=_descriptor._internal_create_key),
 58 |     _descriptor.EnumValueDescriptor(
 59 |       name='FORWARDER', index=5, number=5,
 60 |       serialized_options=None,
 61 |       type=None,
 62 |       create_key=_descriptor._internal_create_key),
 63 |     _descriptor.EnumValueDescriptor(
 64 |       name='SEQUENCER', index=6, number=6,
 65 |       serialized_options=None,
 66 |       type=None,
 67 |       create_key=_descriptor._internal_create_key),
 68 |     _descriptor.EnumValueDescriptor(
 69 |       name='INTERLEAVER', index=7, number=7,
 70 |       serialized_options=None,
 71 |       type=None,
 72 |       create_key=_descriptor._internal_create_key),
 73 |     _descriptor.EnumValueDescriptor(
 74 |       name='SCHEDULER', index=8, number=8,
 75 |       serialized_options=None,
 76 |       type=None,
 77 |       create_key=_descriptor._internal_create_key),
 78 |     _descriptor.EnumValueDescriptor(
 79 |       name='WORKER', index=9, number=9,
 80 |       serialized_options=None,
 81 |       type=None,
 82 |       create_key=_descriptor._internal_create_key),
 83 |   ],
 84 |   containing_type=None,
 85 |   serialized_options=None,
 86 |   serialized_start=30,
 87 |   serialized_end=186,
 88 | )
 89 | _sym_db.RegisterEnumDescriptor(_MODULEID)
 90 | 
 91 | ModuleId = enum_type_wrapper.EnumTypeWrapper(_MODULEID)
 92 | BROKER = 0
 93 | SERVER = 1
 94 | MHORDERER = 2
 95 | LOCALPAXOS = 3
 96 | GLOBALPAXOS = 4
 97 | FORWARDER = 5
 98 | SEQUENCER = 6
 99 | INTERLEAVER = 7
100 | SCHEDULER = 8
101 | WORKER = 9
102 | 
103 | 
104 | DESCRIPTOR.enum_types_by_name['ModuleId'] = _MODULEID
105 | _sym_db.RegisterFileDescriptor(DESCRIPTOR)
106 | 
107 | 
108 | # @@protoc_insertion_point(module_scope)
109 | 


--------------------------------------------------------------------------------
/tools/proto/offline_data_pb2.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # Generated by the protocol buffer compiler.  DO NOT EDIT!
 3 | # source: proto/offline_data.proto
 4 | """Generated protocol buffer code."""
 5 | from google.protobuf import descriptor as _descriptor
 6 | from google.protobuf import message as _message
 7 | from google.protobuf import reflection as _reflection
 8 | from google.protobuf import symbol_database as _symbol_database
 9 | # @@protoc_insertion_point(imports)
10 | 
11 | _sym_db = _symbol_database.Default()
12 | 
13 | 
14 | 
15 | 
16 | DESCRIPTOR = _descriptor.FileDescriptor(
17 |   name='proto/offline_data.proto',
18 |   package='slog',
19 |   syntax='proto3',
20 |   serialized_options=None,
21 |   create_key=_descriptor._internal_create_key,
22 |   serialized_pb=b'\n\x18proto/offline_data.proto\x12\x04slog\"4\n\x05\x44\x61tum\x12\x0b\n\x03key\x18\x01 \x01(\x0c\x12\x0e\n\x06record\x18\x02 \x01(\x0c\x12\x0e\n\x06master\x18\x03 \x01(\rb\x06proto3'
23 | )
24 | 
25 | 
26 | 
27 | 
28 | _DATUM = _descriptor.Descriptor(
29 |   name='Datum',
30 |   full_name='slog.Datum',
31 |   filename=None,
32 |   file=DESCRIPTOR,
33 |   containing_type=None,
34 |   create_key=_descriptor._internal_create_key,
35 |   fields=[
36 |     _descriptor.FieldDescriptor(
37 |       name='key', full_name='slog.Datum.key', index=0,
38 |       number=1, type=12, cpp_type=9, label=1,
39 |       has_default_value=False, default_value=b"",
40 |       message_type=None, enum_type=None, containing_type=None,
41 |       is_extension=False, extension_scope=None,
42 |       serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
43 |     _descriptor.FieldDescriptor(
44 |       name='record', full_name='slog.Datum.record', index=1,
45 |       number=2, type=12, cpp_type=9, label=1,
46 |       has_default_value=False, default_value=b"",
47 |       message_type=None, enum_type=None, containing_type=None,
48 |       is_extension=False, extension_scope=None,
49 |       serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
50 |     _descriptor.FieldDescriptor(
51 |       name='master', full_name='slog.Datum.master', index=2,
52 |       number=3, type=13, cpp_type=3, label=1,
53 |       has_default_value=False, default_value=0,
54 |       message_type=None, enum_type=None, containing_type=None,
55 |       is_extension=False, extension_scope=None,
56 |       serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
57 |   ],
58 |   extensions=[
59 |   ],
60 |   nested_types=[],
61 |   enum_types=[
62 |   ],
63 |   serialized_options=None,
64 |   is_extendable=False,
65 |   syntax='proto3',
66 |   extension_ranges=[],
67 |   oneofs=[
68 |   ],
69 |   serialized_start=34,
70 |   serialized_end=86,
71 | )
72 | 
73 | DESCRIPTOR.message_types_by_name['Datum'] = _DATUM
74 | _sym_db.RegisterFileDescriptor(DESCRIPTOR)
75 | 
76 | Datum = _reflection.GeneratedProtocolMessageType('Datum', (_message.Message,), {
77 |   'DESCRIPTOR' : _DATUM,
78 |   '__module__' : 'proto.offline_data_pb2'
79 |   # @@protoc_insertion_point(class_scope:slog.Datum)
80 |   })
81 | _sym_db.RegisterMessage(Datum)
82 | 
83 | 
84 | # @@protoc_insertion_point(module_scope)
85 | 


--------------------------------------------------------------------------------
/tools/requirements.txt:
--------------------------------------------------------------------------------
 1 | bcrypt==3.1.7
 2 | boto3==1.14.48
 3 | botocore==1.17.48
 4 | certifi==2019.11.28
 5 | cffi==1.14.0
 6 | chardet==3.0.4
 7 | cryptography==3.3.2
 8 | docker==4.3.1
 9 | docutils==0.15.2
10 | idna==2.8
11 | jmespath==0.10.0
12 | numpy==1.18.1
13 | paramiko==2.7.1
14 | protobuf==3.14.0
15 | pycparser==2.19
16 | PyNaCl==1.3.0
17 | python-dateutil==2.8.1
18 | requests==2.22.0
19 | s3transfer==0.3.3
20 | six==1.14.0
21 | urllib3==1.26.5
22 | websocket-client==0.57.0
23 | tabulate==0.8.9


--------------------------------------------------------------------------------
/version.h.in:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | #define SLOG_VERSION "@PROJECT_VERSION@"
4 | #define SLOG_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
5 | #define SLOG_VERSION_MINOR @PROJECT_VERSION_MINOR@
6 | #define SLOG_VERSION_PATCH @PROJECT_VERSION_PATCH@


--------------------------------------------------------------------------------
/workload/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | target_sources(slog-core
 2 |   PRIVATE
 3 |     basic.cpp
 4 |     basic.h
 5 |     cockroach.cpp
 6 |     cockroach.h
 7 |     remastering.cpp
 8 |     remastering.h
 9 |     tpcc.cpp
10 |     tpcc.h
11 |     workload.h)
12 | 


--------------------------------------------------------------------------------
/workload/basic.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | 
 5 | #include "common/configuration.h"
 6 | #include "common/string_utils.h"
 7 | #include "common/types.h"
 8 | #include "proto/transaction.pb.h"
 9 | #include "workload/workload.h"
10 | 
11 | using std::vector;
12 | 
13 | namespace slog {
14 | 
15 | class BasicWorkload : public Workload {
16 |  public:
17 |   BasicWorkload(const ConfigurationPtr& config, uint32_t region, const std::string& data_dir,
18 |                 const std::string& params_str, const uint32_t seed = std::random_device()(),
19 |                 const RawParamMap& extra_default_params = {});
20 | 
21 |   std::pair<Transaction*, TransactionProfile> NextTransaction();
22 | 
23 |  protected:
24 |   ConfigurationPtr config_;
25 |   uint32_t local_region_;
26 |   std::vector<int> distance_ranking_;
27 |   int zipf_coef_;
28 | 
29 |   // This is an index of keys by their partition and home.
30 |   // Each partition holds a vector of homes, each of which
31 |   // is a list of keys.
32 |   vector<vector<KeyList>> partition_to_key_lists_;
33 | 
34 |   std::mt19937 rg_;
35 |   RandomStringGenerator rnd_str_;
36 | 
37 |   TxnId client_txn_id_counter_;
38 | };
39 | 
40 | }  // namespace slog


--------------------------------------------------------------------------------
/workload/cockroach.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | 
 5 | #include "common/configuration.h"
 6 | #include "common/types.h"
 7 | #include "proto/transaction.pb.h"
 8 | #include "workload/workload.h"
 9 | 
10 | namespace slog {
11 | 
12 | class CockroachWorkload : public Workload {
13 |  public:
14 |   class ZipfDistribution {
15 |     public:
16 |       ZipfDistribution(int a, int b, double theta) : a_(a), b_(b), theta_(theta) {
17 |         zeta2_ = ComputeZeta(2);
18 |         zetaN_ = ComputeZeta(b_-a_+1);
19 |         alpha_ = 1.0 / (1.0 - theta_);
20 |         eta_ = (1 - std::pow(2.0/(b_-a_+1), 1.0 - theta_)) / (1.0 - zeta2_/zetaN_);
21 |         half_pow_theta_ = 1.0 + std::pow(0.5, theta_);
22 |       }
23 | 
24 |       template<class Generator>
25 |       double operator()(Generator& g) {
26 |         std::uniform_real_distribution<> d;
27 |         double u = d(g);
28 |         double uz = u * zetaN_;
29 |         if (uz < 1) {
30 |           return a_;
31 |         }    
32 |         if (uz < half_pow_theta_) {
33 |           return a_ + 1;
34 |         }
35 |         double spread = b_ - a_ + 1;
36 |         return a_ + spread * std::pow(eta_*u - eta_ + 1.0, alpha_);
37 |       }
38 | 
39 |       int Max() const {
40 |         return b_;
41 |       }
42 | 
43 |     private:
44 |       double ComputeZeta(int n) {
45 |         double res = 0;
46 |         for (int i = 1; i <= n; i++) {
47 |           res += 1.0 / std::pow(i, theta_);
48 |         }
49 |         return res;
50 |       }
51 | 
52 |       int a_;
53 |       int b_;
54 |       double theta_;
55 |       double zeta2_;
56 |       double zetaN_;
57 |       double alpha_;
58 |       double eta_;
59 |       double half_pow_theta_;
60 |   };
61 | 
62 |   CockroachWorkload(const ConfigurationPtr& config, uint32_t region, const std::string& params_str,
63 |                     const uint32_t seed = std::random_device()());
64 | 
65 |   std::pair<Transaction*, TransactionProfile> NextTransaction();
66 | 
67 |  private:
68 |   ConfigurationPtr config_;
69 |   uint32_t local_region_;
70 |   ZipfDistribution zipf_;
71 | 
72 |   std::mt19937 rg_;
73 |   RandomStringGenerator rnd_str_;
74 | 
75 |   TxnId client_txn_id_counter_;
76 | 
77 |   std::vector<uint64_t> KeyBatch(int n);
78 | };
79 | 
80 | }  // namespace slog


--------------------------------------------------------------------------------
/workload/remastering.cpp:
--------------------------------------------------------------------------------
 1 | #include "workload/remastering.h"
 2 | 
 3 | #include "common/proto_utils.h"
 4 | 
 5 | using std::uniform_int_distribution;
 6 | using std::unordered_set;
 7 | 
 8 | namespace slog {
 9 | namespace {
10 | 
11 | // Number of normal transactions to send between each remastering
12 | constexpr char REMASTER_GAP[] = "remaster_gap";
13 | 
14 | const RawParamMap DEFAULT_PARAMS = {{REMASTER_GAP, "50"}};
15 | 
16 | }  // namespace
17 | 
18 | RemasteringWorkload::RemasteringWorkload(const ConfigurationPtr& config, uint32_t region, const string& data_dir,
19 |                                          const string& params_str, const uint32_t seed)
20 |     : BasicWorkload(config, region, data_dir, params_str, seed, DEFAULT_PARAMS) {
21 |   name_ = "remastering";
22 | }
23 | 
24 | std::pair<Transaction*, TransactionProfile> RemasteringWorkload::NextTransaction() {
25 |   if (client_txn_id_counter_ % params_.GetUInt32(REMASTER_GAP) == 0) {
26 |     return NextRemasterTransaction();
27 |   } else {
28 |     return BasicWorkload::NextTransaction();
29 |   }
30 | }
31 | 
32 | std::pair<Transaction*, TransactionProfile> RemasteringWorkload::NextRemasterTransaction() {
33 |   TransactionProfile pro;
34 | 
35 |   pro.client_txn_id = client_txn_id_counter_;
36 | 
37 |   pro.is_multi_home = false;
38 |   pro.is_multi_partition = false;
39 | 
40 |   vector<KeyMetadata> keys;
41 | 
42 |   auto home = uniform_int_distribution<>(0, config_->num_replicas() - 1)(rg_);
43 |   auto partition = uniform_int_distribution<>(0, config_->num_partitions() - 1)(rg_);
44 | 
45 |   auto new_master = (home + 1) % config_->num_replicas();
46 | 
47 |   auto key = partition_to_key_lists_[partition][home].GetRandomColdKey(rg_);
48 |   keys.emplace_back(key, KeyType::WRITE);
49 |   TransactionProfile::Record record{
50 |       .partition = static_cast<uint32_t>(partition),
51 |       .home = static_cast<uint32_t>(home),
52 |       .is_hot = false,
53 |       .is_write = true,
54 |   };
55 | 
56 |   pro.records.insert({key, record});
57 | 
58 |   auto txn = MakeTransaction(keys, {}, new_master);
59 |   txn->mutable_internal()->set_id(client_txn_id_counter_);
60 | 
61 |   client_txn_id_counter_++;
62 | 
63 |   return std::make_pair(txn, pro);
64 | }
65 | 
66 | };  // namespace slog


--------------------------------------------------------------------------------
/workload/remastering.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | 
 5 | #include "workload/basic.h"
 6 | 
 7 | namespace slog {
 8 | 
 9 | class RemasteringWorkload : public BasicWorkload {
10 |  public:
11 |   RemasteringWorkload(const ConfigurationPtr& config, uint32_t region, const std::string& data_dir,
12 |                       const std::string& params_str, const uint32_t seed = std::random_device()());
13 | 
14 |   std::pair<Transaction*, TransactionProfile> NextTransaction();
15 |   std::pair<Transaction*, TransactionProfile> NextRemasterTransaction();
16 | };
17 | 
18 | }  // namespace slog


--------------------------------------------------------------------------------
/workload/tpcc.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | 
 5 | #include "common/configuration.h"
 6 | #include "common/types.h"
 7 | #include "execution/tpcc/constants.h"
 8 | #include "proto/transaction.pb.h"
 9 | #include "workload/workload.h"
10 | 
11 | using std::vector;
12 | 
13 | namespace slog {
14 | 
15 | class TPCCWorkload : public Workload {
16 |  public:
17 |   TPCCWorkload(const ConfigurationPtr& config, uint32_t region, const std::string& params_str,
18 |                std::pair<int, int> id_slot, const uint32_t seed = std::random_device()());
19 | 
20 |   std::pair<Transaction*, TransactionProfile> NextTransaction();
21 | 
22 |  private:
23 |   void NewOrder(Transaction& txn, TransactionProfile& pro, int w_id, int partition);
24 |   void Payment(Transaction& txn, TransactionProfile& pro, int w_id, int partition);
25 |   void OrderStatus(Transaction& txn, int w_id);
26 |   void Deliver(Transaction& txn, int w_id);
27 |   void StockLevel(Transaction& txn, int w_id);
28 | 
29 |   std::vector<int> SelectRemoteWarehouses(int partition);
30 | 
31 |   ConfigurationPtr config_;
32 |   uint32_t local_region_;
33 |   std::vector<int> distance_ranking_;
34 |   int zipf_coef_;
35 |   vector<vector<vector<int>>> warehouse_index_;
36 |   std::mt19937 rg_;
37 |   TxnId client_txn_id_counter_;
38 |   std::vector<int> txn_mix_;
39 | 
40 |   struct TPCCIds {
41 |     TPCCIds(int i = 1) : o_id(tpcc::kOrdPerDist + i), no_o_id(1), h_id(i + 1) {}
42 |     int o_id;
43 |     int no_o_id;
44 |     int h_id;
45 |   };
46 | 
47 |   class TPCCIdGenerator {
48 |    public:
49 |     TPCCIdGenerator() = default;
50 |     TPCCIdGenerator(int w, int init, int step) : max_o_id_(tpcc::kOrdPerDist), step_(step) {
51 |       ids_.reserve(w);
52 |       for (int i = 0; i < w; i++) {
53 |         auto& warehouse = ids_.emplace_back();
54 |         for (size_t j = 0; j < warehouse.size(); j++) {
55 |           warehouse[j] = TPCCIds(init);
56 |         }
57 |       }
58 |     }
59 | 
60 |     int NextOId(int w_id, int d_id) {
61 |       auto o_id = ids_[w_id - 1][d_id - 1].o_id++;
62 |       max_o_id_ = std::max(max_o_id_, o_id);
63 |       return o_id;
64 |     }
65 | 
66 |     int NextNOOId(int w_id, int d_id) { return ids_[w_id - 1][d_id - 1].no_o_id++; }
67 | 
68 |     int NextHId(int w_id, int d_id) { return ids_[w_id - 1][d_id - 1].h_id++; }
69 | 
70 |     int max_o_id() const { return max_o_id_; }
71 | 
72 |    private:
73 |     std::vector<std::array<TPCCIds, tpcc::kDistPerWare>> ids_;
74 |     int max_o_id_;
75 |     int step_;
76 |   } id_generator_;
77 | };
78 | 
79 | }  // namespace slog


--------------------------------------------------------------------------------