@article{yoon2023sage,

title = {SAGE: toward on-the-fly gradient compression ratio scaling},

author = {Daegun Yoon and Minjoong Jeong and Sangyoon Oh},

url = {https://link.springer.com/article/10.1007/s11227-023-05120-7},

doi = {https://doi.org/10.1007/s11227-023-05120-7},

year  = {2023},

date = {2023-02-25},

urldate = {2023-02-25},

journal = {The Journal of Supercomputing},

pages = {1--23},

abstract = {Gradient sparsification is widely adopted in distributed training; however, it suffers from a trade-off between computation and communication. The prevalent Top-k sparsifier has a hard constraint on computational overhead while achieving the desired gradient compression ratio. Conversely, the hard-threshold sparsifier eliminates computational constraints but fail to achieve the targeted compression ratio. Motivated by this tradeoff, we designed a novel threshold-based sparsifier called SAGE, which achieves a compression ratio close to that of the Top-k sparsifier with negligible computational overhead. SAGE scales the compression ratio by deriving an adjustable threshold based on each iteration’s heuristics. Experimental results show that SAGE achieves a compression ratio closer to the desired ratio than a hard-threshold sparsifier without exacerbating the accuracy of model training. In terms of computation time for gradient selection, SAGE achieves a speedup of up to 23.62×

 over the Top-k sparsifier.},

keywords = {distributed deep learning, gradient sparsification},

pubstate = {published},

tppubtype = {article}

}

@article{Yoon2022WAVE,

title = {WAVE: designing a heuristics-based three-way breadth-first search on GPUs},

author = {Daegun Yoon and Minjoong Jeong and Sangyoon Oh},

doi = {10.1007/s11227-022-04934-1},

year  = {2022},

date = {2022-11-17},

urldate = {2022-11-17},

journal = {The Journal of Supercomputing},

abstract = {Breadth-first search (BFS) is a building block for improving the performance of many iterative graph algorithms. In addition to conventional BFS (push), a novel method that traverses a graph in the reverse direction (pull) has emerged and gained popularity because of its enhanced processing performance. Several frameworks have recently used a hybrid approach known as direction-optimizing BFS, which utilizes both directions. However, these frameworks are mostly interested in optimizing the procedure in each direction, instead of designing sophisticated methods for determining the appropriate direction between push and pull at each iteration. Owing to the lack of in-depth discussion on this decision, state-of-the-art direction-optimizing BFS algorithms cannot demonstrate their comprehensive performance despite improvements in the design of each direction because they select ineffective directions at each iteration. We identified that the current frameworks suffer from high computational overheads for their decisions and make decisions that are overfitted to several graph datasets used for tuning their direction selection process. Based on observations from state-of-the-art limitations, we designed a direction-optimizing method for BFS called WAVE. WAVE minimizes the computational overhead to near zero and makes more appropriate direction selection decisions than the state-of-the-art heuristics based on the characteristics extracted from the input graph dataset. In our experiments on 20 graph benchmarks, WAVE achieved speedups of up to 4.95×, 5.79×, 46.49×, and 149.67× over Enterprise, Gunrock, Tigr, and CuSha, respectively.},

note = {2},

keywords = {breath-first search, direction-optimizing BFS, GPU, graph, push-pull},

pubstate = {published},

tppubtype = {article}

}

@article{여상호2022Crossover-SGD,

title = {Crossover-SGD: A gossip-based communication in distributed deep learning for alleviating large mini-batch problem and enhancing scalability},

author = {여상호 and 배민호 and 정민중 and 권오경 and 오상윤},

url = {https://arxiv.org/abs/2012.15198},

doi = {10.48550/arXiv.2012.15198},

year  = {2022},

date = {2022-11-01},

urldate = {2022-11-01},

journal = {Concurrency and Computation: Practice and Experience},

abstract = {     Distributed deep learning is an effective way to reduce the training time of deep learning for large datasets as well as complex models. However, the limited scalability caused by network overheads makes it difficult to synchronize the parameters of all workers. To resolve this problem, gossip-based methods that demonstrates stable scalability regardless of the number of workers have been proposed. However, to use gossip-based methods in general cases, the validation accuracy for a large mini-batch needs to be verified. To verify this, we first empirically study the characteristics of gossip methods in a large mini-batch problem and observe that the gossip methods preserve higher validation accuracy than AllReduce-SGD(Stochastic Gradient Descent) when the number of batch sizes is increased and the number of workers is fixed. However, the delayed parameter propagation of the gossip-based models decreases validation accuracy in large node scales. To cope with this problem, we propose Crossover-SGD that alleviates the delay propagation of weight parameters via segment-wise communication and load balancing random network topology. We also adapt hierarchical communication to limit the number of workers in gossip-based communication methods. To validate the effectiveness of our proposed method, we conduct empirical experiments and observe that our Crossover-SGD shows higher node scalability than SGP(Stochastic Gradient Push). },

keywords = {deep learning, distributed deep learning},

pubstate = {published},

tppubtype = {article}

}

@article{윤대건2022전술망,

title = {전술망의 라우팅 성능 개선을 위한 성능 지표 분석 기반 정책 엔진 설계},

author = {윤대건 and 노병희 and 오상윤},

url = {https://www.kci.go.kr/kciportal/ci/sereArticleSearch/ciSereArtiView.kci?sereArticleSearchBean.artiId=ART002877193},

year  = {2022},

date = {2022-10-31},

urldate = {2022-10-31},

journal = {한국통신학회 논문지},

volume = {47},

number = {9},

issue = {9},

pages = {1353-1359},

abstract = {컴퓨팅 관련 기술 발달에 따라 군 작전 수행에서 발생하는 데이터의 규모가 매우 커지고 있으며, 이에 따라 이를 처리하기 위한 군 전술망의 성능 향상에 대한 요구 또한 점점 늘어나고 있다. 군 전술망의 특성 상 다양한 장비로 구성된 네트워크를 활용해야 하며, 이러한 상황에서 민간에서 활발히 적용되는 Software-Defined Network (SDN) 기술을 적용한다면 장비를 제공 벤더로부터 자유로운 손쉬운 네트워크 관리가 가능하다. 본 논문에서는SDN 기반 네트워크 환경에서 패킷 전송 성능 향상을 목적으로 하는 네트워크 정책 엔진 구조 설계를 소개한다.

정책 엔진은 Flow table의 Flow들이 나타내는 라우팅 경로를 수정하도록 하는 알고리즘을 포함하며 성능 개선 여부는 본 연구에서 정의한 종합 성능 지표를 통해 판단한다. 추후 본 연구에서 제안하는 전술망 라우팅 성능 개량을 위한 성능 지표 분석 기반 정책 엔진 기반의 소프트웨어를 실제 네트워크 운용 상황에 적용하고, 네트워크 성능 향상을 검증하도록 할 계획이다.},

keywords = {software-defined networking},

pubstate = {published},

tppubtype = {article}

}

@article{이승준2022SDN,

title = {SDN 정책엔진의 사용자 모듈을 위한 분석 요청 정의 언어},

author = {이승준 and 윤대건 and 오상윤},

url = {https://www.kci.go.kr/kciportal/ci/sereArticleSearch/ciSereArtiView.kci?sereArticleSearchBean.artiId=ART002877194},

year  = {2022},

date = {2022-09-01},

urldate = {2022-09-01},

journal = {한국통신학회 논문지},

volume = {47},

number = {9},

pages = {1360-1369},

abstract = {현대전에서 작전 수행은 네트워크 중심전의 양상을 띄고 있으며, 이에 따라 군 전술망 자원을 효과적으로 사용하기 위한 여러 연구가 진행되고 있다. 단일 연구 결과가 아닌 여러 연구의 결과를 복합적으로 적용했을 때의 효과를 분석하기 위한 노력의 일환으로 통합 테스트베드가 구축되고, 여기에서 여러 네트워크 알고리즘을 동시에 수행하고 성능을 분석하기 위한 정책 엔진도 설계되었다. 하지만 이종 네트워크 환경에서는 사용자들이 요구하는 서른 다른 데이터 구조의 성능 지표와 이를 처리할 각 알고리즘의 서로 다른 실행 환경에 적응적으로 대응하기 어려운 문제가 있었다. 이에 본 연구에서는 프로그래밍 언어와 실행 환경 등 특정 기술에 종속되지 않는 정책 엔진을 위한 XML 기반의 인터페이스 포맷을 정의하고 그 스키마를 제안한다. 제안된 스키마를 사용하여 메시지는 특정 프로그래밍 언어에 종속되지 않고 인코딩과 디코딩을 할 수 있으며 Open Container Initiative 표준을 기반으로실행 환경을 정의하는 컨테이너를 기술할 수 있다.



In modern warfare environment, the well defined networks becomes important to the operations. Thus, researchers study on how to use the military tactical network resources effectively. To analyze effectiveness of the results from multiple studies together, an integrated testbed is critical as well as the design and the implementation of a policy engine that performs multiple network algorithms and analyze performance simultaneously. However, when the network environment is heterogeneous, it is hard to respond adaptively to the performance indicators of the different data structures and the different execution environments of each user algorithm. To address this issue, we propose an XML-based interface format and its schema for the policy engine, which is independent from specific technologies such as programming languages and execution environments. A message from and to the policy engine and the testbed can be encoded and decoded regardless of the programming language. Furthermore, it can describe containers of the execution environment based on the Open Container Initiative standard.},

keywords = {interfacing, rule engine, 인터페이스 정의 언어, 정책 엔진, 테스트베드},

pubstate = {published},

tppubtype = {article}

}

@article{Juwon2022AMBLE,

title = {AMBLE: Adjusting Mini-Batch and Local Epoch for Federated Learning with Heterogeneous Devices},

author = {Juwon Park and Daegun Yoon and Sangho Yeo and Sangyoon Oh},

url = {https://www.sciencedirect.com/science/article/pii/S0743731522001757},

doi = {https://doi.org/10.1016/j.jpdc.2022.07.009},

issn = {0743-7315},

year  = {2022},

date = {2022-07-21},

urldate = {2022-07-21},

journal = {Journal of Parallel and Distributed Computing},

abstract = {As data privacy becomes increasingly important, federated learning applied to the training of deep learning models while ensuring the data privacy of devices is entering the spotlight. Federated learning makes it possible to process all data at once while processing data independently from various devices without collecting distributed local data in a central server. However, there are still challenges to overcome for the system of devices in federated learning such as communication overheads and the heterogeneity of the system. In this paper, we propose the Adjusting Mini-Batch and Local Epoch (AMBLE) approach, which adaptively adjusts the local mini-batch and local epoch size for heterogeneous devices in federated learning and updates the parameters synchronously. With AMBLE, we enhance the computational efficiency by removing stragglers and scaling the local learning rate to improve the model convergence rate and accuracy. We verify that federated learning with AMBLE is a stably trained model with a faster convergence speed and higher accuracy than FedAvg and adaptive batch size scheme for both identically and independently distributed (IID) and non-IID cases.},

keywords = {federated learning, Local mini-batch SGD, System heterogeneity},

pubstate = {published},

tppubtype = {article}

}

@article{yoon2022surf,

title = {SURF: Direction-Optimizing Breadth-First Search Using Workload State on GPUs},

author = {Daegun Yoon and Sangyoon Oh},

url = {https://www.mdpi.com/1424-8220/22/13/4899},

doi = {https://doi.org/10.3390/s22134899},

year  = {2022},

date = {2022-06-29},

urldate = {2022-01-01},

journal = {Sensors},

volume = {22},

number = {13},

pages = {4899},

publisher = {Multidisciplinary Digital Publishing Institute},

abstract = { Graph data structures have been used in a wide range of applications including scientific and social network applications. Engineers and scientists analyze graph data to discover knowledge and insights by using various graph algorithms. A breadth-first search (BFS) is one of the fundamental building blocks of complex graph algorithms and its implementation is included in graph libraries for large-scale graph processing. In this paper, we propose a novel direction selection method, SURF (Selecting directions Upon Recent workload of Frontiers) to enhance the performance of BFS on GPU. A direction optimization that selects the proper traversal direction of a BFS execution between the push and pull phases is crucial to the performance as well as for efficient handling of the varying workloads of the frontiers. However, existing works select the direction using condition statements based on predefined thresholds without considering the changing workload state. To solve this drawback, we define several metrics that describe the state of the workload and analyze their impact on the BFS performance. To show that SURF selects the appropriate direction, we implement the direction selection method with a deep neural network model that adopts those metrics as the input features. Experimental results indicate that SURF achieves a higher direction prediction accuracy and reduced execution time in comparison with existing state-of-the-art methods that support a direction-optimizing BFS. SURF yields up to a 5.62×},

keywords = {breath-first search, direction-optimizing BFS, frontier workload, GPU},

pubstate = {published},

tppubtype = {article}

}

@article{s21248416,

title = {Mitigating Cold Start Problem in Serverless Computing with Function Fusion},

author = {Seungjun Lee and Daegun Yoon and Sangho Yeo and Sangyoon Oh},

url = {https://www.mdpi.com/1424-8220/21/24/8416},

doi = {10.3390/s21248416},

issn = {1424-8220},

year  = {2021},

date = {2021-12-23},

urldate = {2021-12-16},

journal = {Sensors},

volume = {21},

number = {24},

abstract = {As Artificial Intelligence (AI) is becoming ubiquitous in many applications, serverless computing is also emerging as a building block for developing cloud-based AI services. Serverless computing has received much interest because of its simplicity, scalability, and resource efficiency. However, due to the trade-off with resource efficiency, serverless computing suffers from the cold start problem, that is, a latency between a request arrival and function execution. The cold start problem significantly influences the overall response time of workflow that consists of functions because the cold start may occur in every function within the workflow. Function fusion can be one of the solutions to mitigate the cold start latency of a workflow. If two functions are fused into a single function, the cold start of the second function is removed; however, if parallel functions are fused, the workflow response time can be increased because the parallel functions run sequentially even if the cold start latency is reduced. This study presents an approach to mitigate the cold start latency of a workflow using function fusion while considering a parallel run. First, we identify three latencies that affect response time, present a workflow response time model considering the latency, and efficiently find a fusion solution that can optimize the response time on the cold start. Our method shows a response time of 28%–86% of the response time of the original workflow in five workflows.},

keywords = {function fusion, serverless computing, serverless workflow, workflow organization},

pubstate = {published},

tppubtype = {article}

}