Data Transmission Service：Makalah Putih Kinerja

Instal Sysbench

1. Unduh dan instal Sysbench pada instance ECS.

   # Instal pustaka dependensi Sysbench.
   yum -y install make automake libtool pkgconfig libaio-devel
   yum -y install mariadb-devel openssl-devel
   
   # Unduh kode sumber Sysbench.
   wget "https://codeload.github.com/akopytov/sysbench/zip/refs/tags/1.0.20" -O sysbench-1.0.20.zip
   
   # Instal utilitas Unzip.
   yum -y install unzip
   
   # Ekstrak kode sumber.
   unzip sysbench-1.0.20.zip
   
   # Kompilasi kode sumber.
   cd sysbench-1.0.20
   ./autogen.sh
   ./configure
   sed -i 's/MYSQL_OPT_COMPRESSION_ALGORITHMS/MYSQL_OPT_COMPRESS/g' ./src/drivers/mysql/drv_mysql.c
   make -j
   
   # Instal Sysbench.
   make install

2. Siapkan skrip Lua untuk skenario berikut: tabel besar (dm_large_table_write_only.lua), pembaruan data panas (dm_hot_update_only.lua), dan sinkronisasi DDL (dm_ddl_only.lua).

   Skrip Lua

   dm_large_table_write_only.lua

   #!/usr/bin/env sysbench
   -- Copyright (C) 2006-2017 Alexey Kopytov <akopytov@gmail.com>
   
   -- Program ini adalah perangkat lunak gratis; Anda dapat mendistribusikannya kembali dan/atau memodifikasinya
   -- di bawah ketentuan GNU General Public License sebagaimana diterbitkan oleh
   -- Free Software Foundation; baik versi 2 dari Lisensi tersebut, atau
   -- (atas pilihan Anda) versi lainnya.
   
   -- Program ini didistribusikan dengan harapan bahwa itu akan berguna,
   -- tetapi TANPA JAMINAN APA PUN; tanpa bahkan jaminan tersirat dari
   -- KELAYAKAN UNTUK DIPERJUALBELIKAN atau KESESUAIAN UNTUK TUJUAN TERTENTU. Lihat
   -- GNU General Public License untuk detail lebih lanjut.
   
   -- Anda seharusnya telah menerima salinan GNU General Public License
   -- bersama dengan program ini; jika tidak, tulis ke Free Software
   -- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   
   -- ----------------------------------------------------------------------
   -- Benchmark tabel besar untuk migrasi data
   -- ----------------------------------------------------------------------
   require("oltp_common")
   
   local function get_table_num()
      return sysbench.rand.uniform(1, sysbench.opt.tables)
   end
   
   local function get_id()
      return sysbench.rand.default(1, sysbench.opt.table_size)
   end
   
   -- Hasilkan template string besar, ukuran 1024 * 50
   local function get_large_templete()
      local large_temp = ""
      for i=1,1024 do
         large_temp = large_temp .. "#########-#########-#########-#########-#########-"
      end
      return large_temp
   end
   
   -- Hasilkan template string besar, ukuran 1024 * 50
   local large_template = get_large_templete()
   
   -- Hasilkan nilai besar, ukuran 1024 * 50
   local function get_large_value()
      return sysbench.rand.string(large_template)
   end
   
   function large_create_table(drv, con, table_num)
      if drv:name() == "mysql"
      then
         print(string.format("Membuat tabel mysql 'sbtest%d'...", table_num))
      else
         error("Driver database tidak didukung:" .. drv:name())
      end
   
      query = string.format([[
   CREATE TABLE sbtest%d(
     id int not null auto_increment,
     k INTEGER DEFAULT '0' NOT NULL,
     c longtext,
     pad longtext,
     primary key (id)
   ) ]],table_num)
   
      con:query(query)
   
      if (sysbench.opt.table_size > 0) then
         print(string.format("Menyisipkan %d catatan ke 'sbtest%d'",
                             sysbench.opt.table_size, table_num))
      end
      query = "INSERT INTO sbtest" .. table_num .. "(k, c, pad) VALUES"
      con:bulk_insert_init(query)
   
      for i = 1, sysbench.opt.table_size do
   
         local large_value = get_large_value()
         query = string.format("(%d, '%s', '%s')",
                                  sysbench.rand.default(1, sysbench.opt.table_size),
                                  large_value, large_value)
         con:bulk_insert_next(query)
      end
   
      con:bulk_insert_done()
   
      if sysbench.opt.create_secondary then
         print(string.format("Membuat indeks sekunder pada 'sbtest%d'...",
                             table_num))
         con:query(string.format("CREATE INDEX k_%d ON sbtest%d(k)",
                                 table_num, table_num))
      end
   end
   
   
   function execute_delete_inserts_large()
      local tnum = get_table_num()
   
      for i = 1, sysbench.opt.delete_inserts do
         local id = get_id()
         local k = get_id()
   
         param[tnum].deletes[1]:set(id)
   
         param[tnum].inserts[1]:set(id)
         param[tnum].inserts[2]:set(k)
         param[tnum].inserts[3]:set_rand_str(large_template)
         param[tnum].inserts[4]:set_rand_str(large_template)
   
         stmt[tnum].deletes:execute()
         stmt[tnum].inserts:execute()
      end
   end
   
   function execute_non_index_updates_large()
      local tnum = get_table_num()
   
      for i = 1, sysbench.opt.non_index_updates do
         param[tnum].non_index_updates[1]:set_rand_str(large_template)
         param[tnum].non_index_updates[2]:set(get_id())
   
         stmt[tnum].non_index_updates:execute()
      end
   end
   
   local t = sysbench.sql.type
   local stmt_defs = {
      point_selects = {
         "SELECT c FROM sbtest%u WHERE id=?",
         t.INT},
      simple_ranges = {
         "SELECT c FROM sbtest%u WHERE id BETWEEN ? AND ?",
         t.INT, t.INT},
      sum_ranges = {
         "SELECT SUM(k) FROM sbtest%u WHERE id BETWEEN ? AND ?",
          t.INT, t.INT},
      order_ranges = {
         "SELECT c FROM sbtest%u WHERE id BETWEEN ? AND ? ORDER BY c",
          t.INT, t.INT},
      distinct_ranges = {
         "SELECT DISTINCT c FROM sbtest%u WHERE id BETWEEN ? AND ? ORDER BY c",
         t.INT, t.INT},
      index_updates = {
         "UPDATE sbtest%u SET k=k+1 WHERE id=?",
         t.INT},
      non_index_updates = {
         "UPDATE sbtest%u SET c=? WHERE id=?",
         {t.CHAR, 51200}, t.INT},
      deletes = {
         "DELETE FROM sbtest%u WHERE id=?",
         t.INT},
      inserts = {
         "INSERT INTO sbtest%u (id, k, c, pad) VALUES (?, ?, ?, ?)",
         t.INT, t.INT, {t.CHAR, 51200}, {t.CHAR, 51200}},
   }
   
   function prepare_for_each_large_table(key)
      for t = 1, sysbench.opt.tables do
         stmt[t][key] = con:prepare(string.format(stmt_defs[key][1], t))
   
         local nparam = #stmt_defs[key] - 1
   
         if nparam > 0 then
            param[t][key] = {}
         end
   
         for p = 1, nparam do
            local btype = stmt_defs[key][p+1]
            local len
   
            if type(btype) == "table" then
               len = btype[2]
               btype = btype[1]
            end
            if btype == sysbench.sql.type.VARCHAR or
               btype == sysbench.sql.type.CHAR then
                  param[t][key][p] = stmt[t][key]:bind_create(btype, len)
            else
               param[t][key][p] = stmt[t][key]:bind_create(btype)
            end
         end
   
         if nparam > 0 then
            stmt[t][key]:bind_param(unpack(param[t][key]))
         end
      end
   end
   
   -- Timpa fungsi create_table oltp_common  
   create_table = large_create_table
   
   -- Timpa fungsi prepare_for_each_table oltp_common  
   prepare_for_each_table = prepare_for_each_large_table
   
   -- Timpa fungsi execute_delete_inserts oltp_common  
   execute_delete_inserts = execute_delete_inserts_large
   
   -- Timpa fungsi execute_non_index_updates oltp_common  
   execute_non_index_updates = execute_non_index_updates_large
   
   function prepare_statements()
      if not sysbench.opt.skip_trx then
         prepare_begin()
         prepare_commit()
      end
   
      prepare_index_updates()
      prepare_non_index_updates()
      prepare_delete_inserts()
   end
   
   function event()
      if not sysbench.opt.skip_trx then
         begin()
      end
   
      execute_index_updates()
      execute_non_index_updates()
      execute_delete_inserts()
   
      if not sysbench.opt.skip_trx then
         commit()
      end
   end

   dm_hot_update_only.lua

   #!/usr/bin/env sysbench
   -- Copyright (C) 2006-2017 Alexey Kopytov <akopytov@gmail.com>
   
   -- Program ini adalah perangkat lunak gratis; Anda dapat mendistribusikannya kembali dan/atau memodifikasinya
   -- di bawah ketentuan GNU General Public License sebagaimana diterbitkan oleh
   -- Free Software Foundation; baik versi 2 dari Lisensi tersebut, atau
   -- (atas pilihan Anda) versi lainnya.
   
   -- Program ini didistribusikan dengan harapan bahwa itu akan berguna,
   -- tetapi TANPA JAMINAN APA PUN; tanpa bahkan jaminan tersirat dari
   -- KELAYAKAN UNTUK DIPERJUALBELIKAN atau KESESUAIAN UNTUK TUJUAN TERTENTU. Lihat
   -- GNU General Public License untuk detail lebih lanjut.
   
   -- Anda seharusnya telah menerima salinan GNU General Public License
   -- bersama dengan program ini; jika tidak, tulis ke Free Software
   -- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   
   -- ----------------------------------------------------------------------
   -- Benchmark pembaruan panas untuk migrasi data
   -- ----------------------------------------------------------------------
   require("oltp_common")
   
   function create_hot_update_table(drv, con, table_num)
      local query
      if table_num < 3
      then
         query = string.format([[
            CREATE TABLE IF NOT EXISTS sbtest%d(
              id int not null auto_increment,
              k INTEGER DEFAULT '0' NOT NULL,
              primary key (id)
            )]], table_num)
               con:query(query)
         query = string.format([[
            CREATE PROCEDURE generate_hot_update_sbtest%d (IN id_val int(11), IN update_count int(11) )
            BEGIN
              DECLARE i int default 1;
              INSERT IGNORE INTO sbtest%d (id,k) values(id_val,id_val); 
              WHILE i<=update_count DO
                  UPDATE sbtest%d SET k=k+1 where id=id_val; 
                  SET i = i + 1;
              END WHILE;
            END]], table_num, table_num, table_num)
               con:query(query)
      else
         print(string.format("Abaikan pembuatan tabel sbtest%d",table_num))
      end
   end
   
   -- Timpa fungsi create_table oltp_common  
   create_table = create_hot_update_table
   
   function prepare_statements()
   end
   
   local function get_table_num()
      return sysbench.rand.uniform(1, 2)
   end
   
   local function get_id()
      return sysbench.rand.default(1, 10)
   end
   
   function event()
      local table_id
      local query
      local id_val
   
      id_val = get_id()
   
      table_id = get_table_num()
      query = string.format("CALL generate_hot_update_sbtest%d(%d,10)",table_id, id_val)
      con:query(query)
   end
   

   dm_ddl_only.lua

   #!/usr/bin/env sysbench
   -- Copyright (C) 2006-2017 Alexey Kopytov <akopytov@gmail.com>
   
   -- Program ini adalah perangkat lunak gratis; Anda dapat mendistribusikannya kembali dan/atau memodifikasinya
   -- di bawah ketentuan GNU General Public License sebagaimana diterbitkan oleh
   -- Free Software Foundation; baik versi 2 dari Lisensi tersebut, atau
   -- (atas pilihan Anda) versi lainnya.
   
   -- Program ini didistribusikan dengan harapan bahwa itu akan berguna,
   -- tetapi TANPA JAMINAN APA PUN; tanpa bahkan jaminan tersirat dari
   -- KELAYAKAN UNTUK DIPERJUALBELIKAN atau KESESUAIAN UNTUK TUJUAN TERTENTU. Lihat
   -- GNU General Public License untuk detail lebih lanjut.
   
   -- Anda seharusnya telah menerima salinan GNU General Public License
   -- bersama dengan program ini; jika tidak, tulis ke Free Software
   -- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   
   -- ----------------------------------------------------------------------
   -- Benchmark DDL untuk migrasi data
   -- ----------------------------------------------------------------------
   require("oltp_common")
   
   function empty_create_table(drv, con, table_num)
      print(string.format("Abaikan pembuatan tabel sbtest%d",table_num))
   end
   
   create_table = empty_create_table
   
   function prepare_statements()
   end
   
   local function get_table_num()
      return sysbench.rand.uniform(1, sysbench.opt.tables)
   end
   
   function event()
      local table_id
      local create_query
      local drop_query
   
      table_id = get_table_num()
      create_query = string.format([[
   CREATE TABLE IF NOT EXISTS sbtest%d(
     id int not null auto_increment,
     k INTEGER DEFAULT '0' NOT NULL,
     c CHAR(120) DEFAULT '' NOT NULL,
     pad CHAR(60) DEFAULT '' NOT NULL,
     primary key (id)
   )]],table_id)
      con:query(create_query)
   
      drop_query = string.format("DROP TABLE IF EXISTS sbtest%d",table_id)
      con:query(drop_query)
   end
   

3. Unggah tiga skrip Lua ke instance ECS dan salin ke direktori skrip Sysbench /usr/local/share/sysbench/.

   # Salin skrip untuk skenario di mana tabel besar digunakan.
   cp dm_large_table_write_only.lua /usr/local/share/sysbench/
   # Salin skrip untuk skenario pembaruan data panas.
   cp dm_hot_update_only.lua /usr/local/share/sysbench/
   # Salin skrip untuk skenario sinkronisasi DDL.
   cp dm_ddl_only.lua /usr/local/share/sysbench/

Instal BenchmarkSQL

# Instal Apache Ant.
yum -y install ant

# Unduh kode sumber BenchmarkSQL.
wget "https://github.com/jackysp/benchmarksql/archive/refs/heads/5.0-mysql-support-opt-2.1.zip" -O benchmarksql-5.0-mysql-support-opt-2.1.zip

# Ekstrak kode sumber.
unzip benchmarksql-5.0-mysql-support-opt-2.1.zip

# Bangun kode sumber.
cd benchmarksql-5.0-mysql-support-opt-2.1
ant