├── emdc-os Technical documentation.pdf ├── ebpf_trace.bt ├── triton_trace_parser.py ├── README.md └── inference_profiler_visualizer.ipynb /emdc-os Technical documentation.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kyeonglok/inference_profiler/HEAD/emdc-os Technical documentation.pdf -------------------------------------------------------------------------------- /ebpf_trace.bt: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bpftrace 2 | #include 3 | #include 4 | BEGIN 5 | { 6 | printf("Tracing tcp send/recv. Hit Ctrl-C to end.\n"); 7 | printf("%-8s %-8s %-16s %35s %48s %20s\n", "TIME", "PID", "COMM", "SADDR:SPORT", "DADDR:DPORT", "TIME(ns)"); 8 | } 9 | kprobe:tcp_sendmsg 10 | { 11 | $sk = ((struct sock *) arg0); 12 | $inet_family = $sk->__sk_common.skc_family; 13 | if ($inet_family == AF_INET || $inet_family == AF_INET6) { 14 | if ($inet_family == AF_INET) { 15 | $daddr = ntop($sk->__sk_common.skc_daddr); 16 | $saddr = ntop($sk->__sk_common.skc_rcv_saddr); 17 | } else { 18 | $daddr = ntop($sk->__sk_common.skc_v6_daddr.in6_u.u6_addr8); 19 | $saddr = ntop($sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr8); 20 | } 21 | $lport = $sk->__sk_common.skc_num; 22 | $dport = $sk->__sk_common.skc_dport; 23 | // Destination port is big endian, it must be flipped 24 | $dport = ($dport >> 8) | (($dport << 8) & 0x00FF00); 25 | $state = $sk->__sk_common.skc_state; 26 | time("%H:%M:%S "); 27 | printf("%-8d %-16s ", pid, comm); 28 | printf("%39s:%-6d %39s:%-6d", $saddr, $lport, $daddr, $dport); 29 | printf("\t%-10u",elapsed); 30 | printf(" *SEND\n") 31 | } 32 | } 33 | kprobe:tcp_recvmsg 34 | { 35 | $sk = ((struct sock *) arg0); 36 | $inet_family = $sk->__sk_common.skc_family; 37 | if ($inet_family == AF_INET || $inet_family == AF_INET6) { 38 | if ($inet_family == AF_INET) { 39 | $daddr = ntop($sk->__sk_common.skc_daddr); 40 | $saddr = ntop($sk->__sk_common.skc_rcv_saddr); 41 | } else { 42 | $daddr = ntop($sk->__sk_common.skc_v6_daddr.in6_u.u6_addr8); 43 | $saddr = ntop($sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr8); 44 | } 45 | $lport = $sk->__sk_common.skc_num; 46 | $dport = $sk->__sk_common.skc_dport; 47 | // Destination port is big endian, it must be flipped 48 | $dport = ($dport >> 8) | (($dport << 8) & 0x00FF00); 49 | $state = $sk->__sk_common.skc_state; 50 | time("%H:%M:%S "); 51 | printf("%-8d %-16s ", pid, comm); 52 | printf("%39s:%-6d %39s:%-6d", $saddr, $lport, $daddr, $dport); 53 | printf("\t%-10u",elapsed); 54 | printf(" *RECV\n") 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /triton_trace_parser.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python3 2 | 3 | import json 4 | import operator 5 | 6 | def trace(json_data): 7 | 8 | time = {} 9 | timesum = {} 10 | num = 1 11 | count = 0 12 | starttime = 0 13 | for data in json_data: 14 | if data["id"]==num+1: 15 | if "GRPC_WAITREAD_START" in time: 16 | count += 1 17 | time.clear() 18 | num += 1 19 | if num == 2+count: 20 | timesum = time.copy() 21 | else: 22 | for k,v in time.items(): 23 | timesum[k] += v 24 | time.clear() 25 | 26 | if data["id"]==num and "timestamps" in data: 27 | timestamps = data["timestamps"] 28 | for timestamp in timestamps: 29 | if timestamp["name"]=="HTTP_RECV_START": 30 | starttime = timestamp["ns"] 31 | time[timestamp["name"]] = timestamp["ns"]- starttime 32 | 33 | if num == 1+count: 34 | timesum = time.copy() 35 | else: 36 | for k,v in time.items(): 37 | timesum[k] += v 38 | 39 | stime= sorted(timesum.items(), key=operator.itemgetter(1)) 40 | print_func(stime,num-count) 41 | 42 | 43 | 44 | def print_func(stime,num): 45 | 46 | value = [] 47 | for i in range(10): 48 | value.append(stime[i+1][1]-stime[i][1]) 49 | 50 | ### print ### 51 | flag=True 52 | 53 | print() 54 | for t in stime: 55 | print('%-21s'%(t[0]), end="") 56 | print() 57 | 58 | for t in stime: 59 | print('%-21s'%(str(t[1]//num)+" ns"), end="") 60 | print() 61 | for i in stime: 62 | print("----+----------------",end="") 63 | print(">") 64 | for v in value: 65 | if flag: 66 | print('%17s ns'%(v//num), end="") 67 | flag=False 68 | continue 69 | print('%18s ns'%(v//num), end="") 70 | print("\n") 71 | 72 | print("time") 73 | for t in stime: 74 | print('%s'%(str(t[1]//num))) 75 | print("\n") 76 | print("interval") 77 | for v in value: 78 | print('%s'%(v//num)) 79 | print("\n") 80 | 81 | 82 | 83 | if __name__ == '__main__': 84 | 85 | with open("/tmp/trace.json", "r") as f: 86 | contents = f.read() 87 | json_data = json.loads(contents) 88 | 89 | trace(json_data) 90 | 91 | 92 | 93 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # inference_profiler 2 | inference profiler는 triton inference server를 사용한 추론 작업에서 구간별 추론 스택과 OS 커널의 전계층을 프로파일링 할 수 있는 프로파일러입니다. 3 | 커널 스택 분석을 위한 ebpf 및 bpftrace를 활용한 프로파일링 기법과 NVIDIA triton inference server의 프로파일링 도구를 활용하여 통합 프로파일링 인터페이스를 제공합니다. 4 | 5 | ## eBPF및 bpftrace를 활용한 프로파일링 6 | 7 | 1. ebpf_trace.bt는 [bpftrace](https://github.com/iovisor/bpftrace)를 사용하여 작성된 프로그램입니다. 실행을 위해서는 먼저 [bpftrace를 설치](https://github.com/iovisor/bpftrace/blob/master/INSTALL.md)해야합니다. 8 | 9 | - Ubunutu OS에서는 다음의 명령어를 통해 bpftrace를 설치할 수 있습니다. 10 | ``` 11 | $ sudo apt-get install –y bpftrace 12 | ``` 13 | 2. 설치가 완료되었다면 다음의 명령어를 통해 프로그램을 실행할 수 있습니다. 14 | ``` 15 | $ sudo ./ebpf_trace.bt 16 | ``` 17 | 3. 결과 예시 18 | ``` 19 | Attaching 3 probes. . . 20 | Tracing tcp send/recv. Hit Ctrl-C to end. 21 | TIME PID COMM SADDR:SPORT DADDR:DPORT TIME(ms) SEND/RECV 22 | 17:59:47 54643 image_client 127.0.0.1:33782 127.0.0.1:8000 2033 *SEND 23 | 17:59:47 54498 tritonserver 172.17.0.2:8000 172.17.0.1:58736 2033 *RECV 24 | 17:59:47 54498 tritonserver 172.17.0.2:8000 172.17.0.1:58736 2033 *SEND 25 | . . . 26 | ``` 27 | 28 | ## NVIDIA triton inference server의 프로파일링 도구를 활용한 프로파일링 29 | 30 | 1. [NVIDIA triton inference server](https://github.com/triton-inference-server/server)에서는 추론 과정에서의 구간 분석을 위한 [프로파일링 기능](https://github.com/triton-inference-server/server/blob/main/docs/trace.md)을 제공합니다. tritonserver 실행시 다음의 옵션을 추가하여 프로파일링 기능을 사용할 수 있습니다. --trace-file 옵션에서 지정해준 경로에 json 파일 형식으로 프로파일링 결과가 저장됩니다. 31 | ``` 32 | $ tritonserver --trace-file=/tmp/trace.json --trace-rate=100 --trace-level=MAX ... 33 | ``` 34 | 2. tritonserver를 실행한 후 클라이언트에서 요청한 추론 작업을 완료하면 서버를 종료시킵니다. 그 후 다음의 명령어를 실행하면 json파일로 저장되어있는 정보를 분석하여 최종 프로파일링 결과가 출력됩니다. 35 | ``` 36 | $ python3 triton_trace_parser.py 37 | ``` 38 | 3. 결과 예시 39 | ``` 40 | HTTP_RECV_START HTTP_RECV_END REQUEST_START QUEUE_START COMPUTE_START COMPUTE_INPUT_END COMPUTE_OUTPUT_START COMPUTE_END REQUEST_END HTTP_SEND_START HTTP_SEND_END 41 | 0 ns 526015 ns 542254 ns 544639 ns 554494 ns 645533 ns 6312705 ns 6317666 ns 6334089 ns 6336647 ns 6340987 ns 42 | ----+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+--------------------+----------------> 43 | 526015 ns 16239 ns 2384 ns 9855 ns 91038 ns 5667172 ns 4960 ns 16423 ns 2558 ns 4339 ns 44 | ``` 45 | -------------------------------------------------------------------------------- /inference_profiler_visualizer.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Untitled0.ipynb", 7 | "provenance": [] 8 | }, 9 | "kernelspec": { 10 | "name": "python3", 11 | "display_name": "Python 3" 12 | }, 13 | "language_info": { 14 | "name": "python" 15 | } 16 | }, 17 | "cells": [ 18 | { 19 | "cell_type": "code", 20 | "source": [ 21 | "import matplotlib.pyplot as plt\n", 22 | "from datetime import date\n", 23 | "import numpy as np\n", 24 | " \n", 25 | "%matplotlib inline " 26 | ], 27 | "metadata": { 28 | "id": "H9ylBKiRFCmJ" 29 | }, 30 | "execution_count": null, 31 | "outputs": [] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "source": [ 36 | "dates = [0,1,2,3,4,5]\n", 37 | "labels = ['Start','Network+Server Send/Recv','Server Queue','Server Compute Input','Server Compute Infer','Server Compute Output']\n", 38 | "# labels with associated dates\n" 39 | ], 40 | "metadata": { 41 | "id": "bGLoAgTMFLBC" 42 | }, 43 | "execution_count": null, 44 | "outputs": [] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "source": [ 49 | "data_f = open(\"/content/test2.csv\")\n", 50 | "\n", 51 | "temp =[]\n", 52 | "\n", 53 | "flag = 0\n", 54 | "for line in data_f:\n", 55 | " if flag == 0:\n", 56 | " flag += 1\n", 57 | " continue \n", 58 | " temp = line.split(',') \n", 59 | "\n", 60 | "date =[]\n", 61 | "sum = 0\n", 62 | "temp[2] = '0'\n", 63 | "for i in range(6):\n", 64 | " date.append(sum + int(temp[i+2]))\n", 65 | " sum = date[i]\n", 66 | "temp = temp[3:8]\n", 67 | "print(temp)\n", 68 | "data_f.close() \n", 69 | "\n", 70 | "for i in range(len(date)):\n", 71 | " labels[i] = labels[i] + \"\\n\" + str(date[i]) + \" usec\"" 72 | ], 73 | "metadata": { 74 | "colab": { 75 | "base_uri": "https://localhost:8080/" 76 | }, 77 | "id": "09DfCL2xfpl0", 78 | "outputId": "430c66e1-d4ff-4c3e-c27c-b11885884f60" 79 | }, 80 | "execution_count": null, 81 | "outputs": [ 82 | { 83 | "output_type": "stream", 84 | "name": "stdout", 85 | "text": [ 86 | "['20683', '22', '29', '350973', '52']\n" 87 | ] 88 | } 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "source": [ 94 | "font1 = {'family': 'serif',\n", 95 | " 'color': 'dimgrey',\n", 96 | " 'weight': 'normal',\n", 97 | " 'size': 11}" 98 | ], 99 | "metadata": { 100 | "id": "aFt74WHXXNK1" 101 | }, 102 | "execution_count": null, 103 | "outputs": [] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "source": [ 108 | "fig, ax = plt.subplots(figsize=(16, 4), constrained_layout=True)\n", 109 | "ax.set_ylim(-2, 1.75)\n", 110 | "ax.axhline(0, xmin=0.05, xmax=0.95, c='grey', zorder=1)\n", 111 | "ax.scatter(dates, np.zeros(len(dates)), s=120, c='darkgrey', zorder=2)\n", 112 | "ax.scatter(dates, np.zeros(len(dates)), s=30, c='black', zorder=3)\n", 113 | "\n", 114 | "label_offsets = np.zeros(len(dates))\n", 115 | "label_offsets[::2] = 0.7\n", 116 | "label_offsets[1::2] = -1\n", 117 | "for i, (l, d) in enumerate(zip(labels, dates)):\n", 118 | " ax.text(d, label_offsets[i], l, ha='center', fontfamily='serif', fontweight='bold', color='black',fontsize=12)\n", 119 | "\n", 120 | "stems = np.zeros(len(dates))\n", 121 | "stems[::2] = 0.5\n", 122 | "stems[1::2] = -0.5 \n", 123 | "markerline, stemline, baseline = ax.stem(dates, stems, use_line_collection=True)\n", 124 | "plt.setp(markerline, marker=',', color='grey')\n", 125 | "plt.setp(stemline, color='grey')\n", 126 | "\n", 127 | "for spine in [\"left\", \"top\", \"right\", \"bottom\"]:\n", 128 | " _ = ax.spines[spine].set_visible(False)\n", 129 | " \n", 130 | "ax.set_xticks([])\n", 131 | "ax.set_yticks([])\n", 132 | " \n", 133 | "ax.set_title('Inference profiler visualizer', fontweight=\"bold\", fontfamily='serif', fontsize=18, color='black')\n", 134 | "\n", 135 | "i = 0.4\n", 136 | "for time in temp:\n", 137 | " plt.text(i, 0.1, str(time)+\" usec\", fontdict=font1)\n", 138 | " i += 1\n", 139 | "\n", 140 | "\n" 141 | ], 142 | "metadata": { 143 | "colab": { 144 | "base_uri": "https://localhost:8080/", 145 | "height": 301 146 | }, 147 | "id": "Dd1YflD6FNJD", 148 | "outputId": "b178517c-b4ed-4101-f9c5-c4f858ca9b70" 149 | }, 150 | "execution_count": null, 151 | "outputs": [ 152 | { 153 | "output_type": "display_data", 154 | "data": { 155 | "image/png": "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\n", 156 | "text/plain": [ 157 | "
" 158 | ] 159 | }, 160 | "metadata": {} 161 | } 162 | ] 163 | } 164 | ] 165 | } --------------------------------------------------------------------------------