最近给服务增加了一个cache_put_latency指标,加了之后,吓了一跳。发现往memcached put一个10KB左右的数据,latency居然有7ms左右,难于理解,于是花了一些精力找原因。我分别写了一个shell和C++的测试程序。 1、shell脚本使用nc发送set命令。 #/bin/env ba
最近给服务增加了一个cache_put_latency指标,加了之后,吓了一跳。发现往memcached put一个10KB左右的数据,latency居然有7ms左右,难于理解,于是花了一些精力找原因。我分别写了一个shell和C++的测试程序。
1、shell脚本使用nc发送set命令。
#/bin/env bash let s=1 let i=0 let len=8*1024 while true do if (( i >= $len )) then break fi str=${str}1 let i++ done let i=0 begin_time=`date +%s` while true do if (( i >= 1000 )) then break fi printf "set $i 0 0 $len\r\n${str}\r\n" | nc 10.234.4.24 11211 if [[ $? -eq 0 ]] then echo "echo key: $i" fi let i++ done end_time=`date +%s` let use_time=end_time-begin_time echo "set time consumed: $use_time" let i=0 begin_time=`date +%s` while true do if (( i >= 1000 )) then break fi printf "get $i\r\n" | nc 10.234.4.22 11211 > /dev/null 2>&1 let i++ done end_time=`date +%s` let use_time=end_time-begin_time echo "get time consumed: $use_time"
2、C++程序则通过libmemcached set。
#include <iostream> #include <map> #include <string> #include <sys> #include <time.h> #include <stdlib.h> #include "libmemcached/memcached.h" using namespace std; uint32_t item_size = 0; uint32_t loop_num = 0; bool single_server = false; std::string local_ip; std::map<:string uint32_t> servers; int64_t getCurrentTime() { struct timeval tval; gettimeofday(&tval, NULL); return (tval.tv_sec * 1000000LL + tval.tv_usec); } memcached_st* mc_init() { memcached_st * mc = memcached_create(NULL); if (mc == NULL) { cout ::iterator iter; for (iter = servers.begin(); iter != servers.end(); ++iter) { if (single_server && iter->first != local_ip) { continue; } memcached_return rc = memcached_server_add(mc, iter->first.c_str(), iter->second); if(rc != MEMCACHED_SUCCESS) { cout first first <p>测试发现二者的结果是相背的。shell脚本set 1000次8KB的item,只要3s左右,平均需要3ms。而C++版本则需要39s左右,平均耗时39ms。照理说shell脚本需要不断连接服务器和启动nc进程,应该更慢才对。我用ltrace跟踪了一下,发现8KB的数据需要发送两次,两次write都是非常快的,但是等memcached返回时用了很多时间,主要的时间就耗费在这个地方。</p> <pre class="brush:php;toolbar:false"> 23:32:37.069922 [0x401609] memcached_set(0x19076200, 0x7fffdad68560, 32, 0x1907a570, 8192 <unfinished ...> 23:32:37.070034 [0x3f280c5f80] SYS_write(3, "set 29 0 600 8192\r\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"..., 8196) = 8196 23:32:37.071657 [0x3f280c5f80] SYS_write(3, "aaaaaaaaaaaaaaa\r\n", 17) = 17 23:32:37.071741 [0x3f280c5f00] SYS_read(3, "STORED\r\n", 8196) = 8 (39ms) </unfinished>
和剑豪讨论下之后,剑豪马上去grep了一把代码,发现原来libmemcached居然有MEMCACHED_MAX_BUFFER这样一个常量,其值为8196。并且它还没有对应的memcached_behavior_set函数。在memcached_constants.h中将其直接改成81960,然后就欣喜地发现cache_put_latency从7ms降低到1ms左右。
问题完美虽然地解决了,但是意犹未尽,于是想搞明白为什么会出现这种奇怪的现象。瓶颈貌似在服务器端,于是对memcached做了一些修改。在状态切换的时候加上一个精确到微秒的时间。
static int64_t getCurrentTime() { struct timeval tval; gettimeofday(&tval, NULL); return (tval.tv_sec * 1000000LL + tval.tv_usec); } static void conn_set_state(conn *c, enum conn_states state) { assert(c != NULL); assert(state >= conn_listening && state state) { if (settings.verbose > 2) { fprintf(stderr, "%d: going from %s to %s, time: %lu\n", c->sfd, state_text(c->state), state_text(state), getCurrentTime()); } c->state = state; if (state == conn_write || state == conn_mwrite) { MEMCACHED_PROCESS_COMMAND_END(c->sfd, c->wbuf, c->wbytes); } } }
从打印的时间戳可以看出来,时间主要花在conn_nread状态处理代码中。最后定位到第二次read花费的时间非常多。
15: going from conn_waiting to conn_read, time: 1348466584440118 15: going from conn_read to conn_parse_cmd, time: 1348466584440155 NOT FOUND 98 >15 STORED 15: going from conn_nread to conn_write, time: 1348466584480099(36ms) 15: going from conn_write to conn_new_cmd, time: 1348466584480145 15: going from conn_new_cmd to conn_waiting, time: 1348466584480152
value的数据可能在conn_read中读完了,这个时候只需要memmove一下就好了。如果没有在conn_read状态中读完,那么就需要conn_nread自己来一次read了(因为套接字被设置成了异步,所以还可能需要多次read),关键就是这个read太慢了。
case conn_nread: if (c->rlbytes == 0) { complete_nread(c); break; } /* first check if we have leftovers in the conn_read buffer */ if (c->rbytes > 0) { int tocopy = c->rbytes > c->rlbytes ? c->rlbytes : c->rbytes; if (c->ritem != c->rcurr) { memmove(c->ritem, c->rcurr, tocopy); } c->ritem += tocopy; c->rlbytes -= tocopy; c->rcurr += tocopy; c->rbytes -= tocopy; if (c->rlbytes == 0) { break; } } /* now try reading from the socket */ res = read(c->sfd, c->ritem, c->rlbytes); if (res > 0) { pthread_mutex_lock(&c->thread->stats.mutex); c->thread->stats.bytes_read += res; pthread_mutex_unlock(&c->thread->stats.mutex); if (c->rcurr == c->ritem) { c->rcurr += res; } c->ritem += res; c->rlbytes -= res; break; }
折腾了好久,在libmemcached的io_flush函数前后也打了不少时间戳,发现libmemcached发送数据是非常快的。突然灵感闪现,我想起来了TCP_NODELAY这个参数,于是在libmemcached memcached_connect.c文件中的set_socket_options函数中增加了这个参数(事实上set_socket_options函数里面可以设置TCP_NODELAY,没有仔细看)。
int flag = 1; int error = setsockopt(ptr->fd, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(flag) ); if (error == -1) { printf("Couldn't setsockopt(TCP_NODELAY)\n"); exit(-1); }else { printf("set setsockopt(TCP_NODELAY)\n"); }
在不改MEMCACHED_MAX_BUFFER的情况下,现在set 100KB的item也是一瞬间的事情了。不过新的困惑又出现了,Nagle算法什么情况会起作用呢?为什么第一个包没被缓存,第二个包一定会被缓存呢?
libmemcached发送一个set命令是分成三部分的,首先是header(set 0 0 600 8192\r\n,共18个字节),然后是value(8192个字节),最后是’\r\n’(两个字节),一共是8212个字节。memcached在conn_read状态一共能读取2048+2048+4096+8196=16KB的数据,因此对于8KB的数据是完全可以在conn_read状态读完的。通过在conn_read状态处理的代码中增加下面的打印语句可以发现有些情况下,conn_read最后一次只读取了4个字节(正常情况应该是2048+2048+4096+20),剩下的16个字节放到conn_nread中读了。
res = read(c->sfd, c->rbuf + c->rbytes, avail); if (res > 0) { char buf[10240] = {0}; sprintf(buf, "%.*s", res, c->rbuf + c->rbytes); printf("avail=%d, read=%d, str=%s\n", avail, res, buf);
未设置TCP_NODELAY选项时,使用netstat可以看到客户端socket的Send-Q一直会维持在8214和8215之间。
tcp 0 8215 10.232.42.91:59836 10.232.42.91:11211 ESTABLISHED 25800/t
设置TCP_NODELAY选项时,客户端socket的Send-Q就一直为0了。
tcp 0 0 10.232.42.91:59890 10.232.42.91:11211 ESTABLISHED 26554/t.quick
原文地址:libmemcached的MEMCACHED_MAX_BUFFER问题, 感谢原作者分享。

Die MySQL -Idium -Kardinalität hat einen signifikanten Einfluss auf die Abfrageleistung: 1. Hoher Kardinalitätsindex kann den Datenbereich effektiver einschränken und die Effizienz der Abfrage verbessern. 2. Niedriger Kardinalitätsindex kann zu einem vollständigen Tischscannen führen und die Abfrageleistung verringern. 3. Im gemeinsamen Index sollten hohe Kardinalitätssequenzen vorne platziert werden, um die Abfrage zu optimieren.

Der MySQL -Lernpfad umfasst Grundkenntnisse, Kernkonzepte, Verwendungsbeispiele und Optimierungstechniken. 1) Verstehen Sie grundlegende Konzepte wie Tabellen, Zeilen, Spalten und SQL -Abfragen. 2) Lernen Sie die Definition, die Arbeitsprinzipien und die Vorteile von MySQL kennen. 3) Master grundlegende CRUD -Operationen und fortgeschrittene Nutzung wie Indizes und gespeicherte Verfahren. 4) KON -Debugging- und Leistungsoptimierungsvorschläge, wie z. B. rationale Verwendung von Indizes und Optimierungsabfragen. In diesen Schritten haben Sie einen vollen Verständnis für die Verwendung und Optimierung von MySQL.

Die realen Anwendungen von MySQL umfassen grundlegende Datenbankdesign und komplexe Abfrageoptimierung. 1) Grundnutzung: Wird zum Speichern und Verwalten von Benutzerdaten verwendet, z. B. das Einfügen, Abfragen, Aktualisieren und Löschen von Benutzerinformationen. 2) Fortgeschrittene Nutzung: Verwandte komplexe Geschäftslogik wie Auftrags- und Bestandsverwaltung von E-Commerce-Plattformen. 3) Leistungsoptimierung: Verbesserung der Leistung durch rationale Verwendung von Indizes, Partitionstabellen und Abfrage -Caches.

SQL -Befehle in MySQL können in Kategorien wie DDL, DML, DQL und DCL unterteilt werden und werden verwendet, um Datenbanken und Tabellen zu erstellen, zu ändern, zu löschen, Daten einfügen, aktualisieren, Daten löschen und komplexe Abfragebetriebe durchführen. 1. Die grundlegende Verwendung umfasst die Erstellungstabelle erstellbar, InsertInto -Daten einfügen und Abfragedaten auswählen. 2. Die erweiterte Verwendung umfasst die Zusammenarbeit mit Tabellenverbindungen, Unterabfragen und GroupBy für die Datenaggregation. 3.. Häufige Fehler wie Syntaxfehler, Datentyp -Nichtübereinstimmung und Berechtigungsprobleme können durch Syntaxprüfung, Datentypkonvertierung und Berechtigungsmanagement debuggen. 4. Vorschläge zur Leistungsoptimierung umfassen die Verwendung von Indizes, die Vermeidung vollständiger Tabellenscanning, Optimierung von Join -Operationen und Verwendung von Transaktionen, um die Datenkonsistenz sicherzustellen.

InnoDB erreicht Atomizität durch Ungewöhnung, Konsistenz und Isolation durch Verriegelungsmechanismus und MVCC sowie Persistenz durch Redolog. 1) Atomizität: Verwenden Sie Unolog, um die Originaldaten aufzuzeichnen, um sicherzustellen, dass die Transaktion zurückgerollt werden kann. 2) Konsistenz: Stellen Sie die Datenkonsistenz durch Verriegelung auf Zeilenebene und MVCC sicher. 3) Isolierung: Unterstützt mehrere Isolationsniveaus und wird standardmäßig WiederholungSead verwendet. 4) Persistenz: Verwenden Sie Redolog, um Modifikationen aufzuzeichnen, um sicherzustellen, dass die Daten für lange Zeit gespeichert werden.

Die Position von MySQL in Datenbanken und Programmierung ist sehr wichtig. Es handelt sich um ein Open -Source -Verwaltungssystem für relationale Datenbankverwaltung, das in verschiedenen Anwendungsszenarien häufig verwendet wird. 1) MySQL bietet effiziente Datenspeicher-, Organisations- und Abruffunktionen und unterstützt Systeme für Web-, Mobil- und Unternehmensebene. 2) Es verwendet eine Client-Server-Architektur, unterstützt mehrere Speichermotoren und Indexoptimierung. 3) Zu den grundlegenden Verwendungen gehören das Erstellen von Tabellen und das Einfügen von Daten, und erweiterte Verwendungen beinhalten Multi-Table-Verknüpfungen und komplexe Abfragen. 4) Häufig gestellte Fragen wie SQL -Syntaxfehler und Leistungsprobleme können durch den Befehl erklären und langsam abfragen. 5) Die Leistungsoptimierungsmethoden umfassen die rationale Verwendung von Indizes, eine optimierte Abfrage und die Verwendung von Caches. Zu den Best Practices gehört die Verwendung von Transaktionen und vorbereiteten Staten

MySQL ist für kleine und große Unternehmen geeignet. 1) Kleinunternehmen können MySQL für das grundlegende Datenmanagement verwenden, z. B. das Speichern von Kundeninformationen. 2) Große Unternehmen können MySQL verwenden, um massive Daten und komplexe Geschäftslogik zu verarbeiten, um die Abfrageleistung und die Transaktionsverarbeitung zu optimieren.

InnoDB verhindert effektiv das Phantom-Lesen durch den Mechanismus für den nächsten Kleien. 1) Nächstschlüsselmesser kombiniert Zeilensperr- und Gap-Sperre, um Datensätze und deren Lücken zu sperren, um zu verhindern, dass neue Datensätze eingefügt werden. 2) In praktischen Anwendungen kann durch Optimierung der Abfragen und Anpassung der Isolationsstufen die Verringerungswettbewerb reduziert und die Gleichzeitleistung verbessert werden.


Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

VSCode Windows 64-Bit-Download
Ein kostenloser und leistungsstarker IDE-Editor von Microsoft

Dreamweaver CS6
Visuelle Webentwicklungstools

WebStorm-Mac-Version
Nützliche JavaScript-Entwicklungstools

Sicherer Prüfungsbrowser
Safe Exam Browser ist eine sichere Browserumgebung für die sichere Teilnahme an Online-Prüfungen. Diese Software verwandelt jeden Computer in einen sicheren Arbeitsplatz. Es kontrolliert den Zugriff auf alle Dienstprogramme und verhindert, dass Schüler nicht autorisierte Ressourcen nutzen.

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung