Page 87 - 《软件学报》2025年第5期
P. 87

温金凤 等: 服务器无感知平台性能度量研究                                                           1987


                    在编程语言方面, 我们主要探究了           Python、JavaScript 和  Java 这  3  种广泛应用于服务器无感知计算的编程语
                 言  [14,15] . 考虑到本文中特征总结的结果, 除了微软      Azure Functions 采用动态内存分配的策略外, 其他       3  个平台都需
                 要开发者提前分配指定的内存大小. 为了统一这               3  个平台的内存分配大小, 本文选择它们都支持的内存大小. 我们
                 了解到, 谷歌   Cloud Functions 支持固定的内存分配大小, 包括      128 MB、256 MB、512 MB、1 024 MB、2 048 MB、
                 4 096 MB、8 192 MB. 亚马逊  Lambda 允许配置  128–10 240 MB  大小之间的数字. 阿里巴巴      Function Compute 则
                 支持从   128 MB  到  32 GB  的内存大小. 然而, 在实验中, 我们发现在亚马逊         Lambda 上部署函数时, 实际上只能设
                 置小于等于    3 008 MB  的内存, 这表明亚马逊     Lambda 官方文档的说明和应用实践可能存在不一致的情况. 因此,
                 综合谷歌   Cloud Functions 和阿里巴巴  Function Compute 的内存分配大小, 我们探究了分别在        128 MB、256 MB、
                 512 MB、1 024 MB  和  2 048 MB  下不同编程语言编写的函数即服务应用的冷启动延迟. 为了直观比较结果, 我们
                 总结了每组实验中       1 000  次度量结果的中位数和上下四分位数范围, 展示在表               6  中. 此外, 具体性能数据分布将展
                 示在图   3–图  9  中. 接下来, 我们将分析平台内和平台间冷启动延迟结果.

                    表 6 不同平台在不同内存分配下执行不同编程语言应用的中位数冷启动延迟和上下四分位数范围                                  (ms)

                            内存大小          亚马逊              谷歌               微软              阿里巴巴
                   编程语言
                              (MB)        Lambda       Cloud Functions   Azure Functions  Function Compute
                                          373.32          3 426.77                           2 717.00
                              128
                                      ([356.93, 397.30])  ([2 943.20, 4 327.96])        ([2 622.52, 2 830.69])
                                          380.33          2 716.03                           2 278.95
                              256
                                      ([359.14, 410.69])  ([2 433.82, 3 102.91])        ([2 212.39, 2 356.42])
                                          377.87          2 695.39         2 824.34          2 251.13
                    Python    512
                                      ([358.34, 409.70])  ([2 393.64, 3 062.36])  ([2 344.57, 3 443.72])  ([1 133.24, 2 326.44])
                                          373.78          2 687.09                           2 217.56
                              1 024
                                      ([355.71, 408.57])  ([2 374.02, 3 086.26])        ([1 120.98, 2 311.82])
                                          379.51          2 678.67                           1 217.99
                              2 048
                                      ([357.44, 413.72])  ([2 407.61, 3 153.06])        ([1 119.33, 2 296.15])
                                          430.52          2 596.22                           1 165.22
                              128
                                      ([410.46, 459.46])  ([2 275.23, 3 036.19])        ([1 128.32, 2 250.42])
                                          432.01          2 593.08                           1 161.28
                              256
                                      ([408.37, 459.66])  ([2 249.28, 2 972.23])        ([1 129.14, 1 542.85])
                                          430.60          2 581.95         2 385.69          1 153.54
                  JavaScript  512
                                      ([411.44, 454.93])  ([2 298.93, 2 978.61])  ([1 943.22, 2 947.28])  ([1 128.48, 1 351.06])
                                          426.96          2 622.05                           1 147.31
                              1 024
                                      ([408.01, 450.22])  ([2 318.50, 3 021.09])        ([1 121.41, 1 236.02])
                                          424.68          2 733.99                           1 161.13
                              2 048
                                      ([405.80, 450.25])  ([2 388.54, 3 037.83])        ([1 137.64, 1 233.54])
                                          783.91          2 940.94                           1 342.00
                              128
                                      ([754.24, 813.84])  ([2 615.94, 3 336.05])        ([1 316.01, 1 400.25])
                                          747.09          2 790.70                           1 346.92
                              256
                                      ([721.93, 779.51])  ([2 486.41, 3 236.96])        ([1 400.25, 1 404.60])
                                          741.41          2 866.50         2 142.25          1 348.16
                    Java      512
                                      ([718.15, 770.26])  ([2 571.00, 3 304.19])  ([1 793.71, 2 777.07])  ([1 319.54, 1 405.88])
                                          736.08          2 839.60                           1 354.29
                              1 024
                                      ([711.02, 766.32])  ([2 532.14, 3 256.73])        ([1 324.68, 1 407.18])
                                          685.07          2 892.08                           1 362.77
                              2 048
                                      ([662.91, 718.81])  ([2 589.00, 3 326.58])        ([1 335.97, 1 416.47])

                    (1) 平台内冷启动延迟比较: 针对每个服务器无感知平台, 我们比较了不同编程语言编写的应用在各个内存分
                 配大小下的冷启动延迟. 对于亚马逊           Lambda 的冷启动性能结果, 从图       3  中可以观察到, 在该平台上执行        Python  应
                 用和  JavaScript 应用的冷启动延迟要低于      Java 应用. 这些结论在为这些应用分别分配          128 MB、256 MB、512 MB、
                 1 024 MB  和  2 048 MB  内存时同样成立. 根据表   6  中亚马逊  Lambda 结果的中位数数据, 以       128 MB  内存大小为
                 例, Python  应用的冷启动延迟为     373.32 ms, JavaScript 应用的冷启动延迟为  430.52 ms, 而  Java 应用的冷启动延迟
   82   83   84   85   86   87   88   89   90   91   92