Microsoft PowerPoint - 사본 - 7월23일-공개용.pptx

금융문제에대한 병렬몬테카를로시뮬레이션 유현곤연세대학교수학과박사과정 Email : yhgon@yonsei.ac.kr 2008 년 7 월 23 일수요일 10 시고려대학교금융세미나

Agenda 1. 연세소개 2. 기초금융과 Monte Carlo Simulation 3. 병렬처리 (pmc) 에대한이해 4. 수퍼컴퓨터를이용한 pmc I (openmp) 5. 수퍼컴퓨터를이용한 pmc II (MPI) 6. 대안적방법론 1 Clearspeed 가속보드를이용한 pmc 7. 대안적방법론 2 CUDA 를이용한 pmc 9. Q & A

연세대학교 http://quant.yonsei.ac.kr/ t / 교수님 3 분, 박사과정 : 4 명, 석사과정 : 12 명, 학부생 : 15 명 금융공학네트워크활성화 금융수학적학술연구 금융공학적상품공동개발및연구 금융 IT 솔루션공동연구 설립목적 연구사업 금융선진화를위한경쟁력제고 산학협력차원의연구와교육 국내외 금융전문인력 협력기관과의 양성프로그램 교류연구 개발공동연구 국내외학술교류해외석학초청세미나 2008년 5회개최산학협력세미나 2008년 7회개최병렬컴퓨팅자문 - LG 전자, KISTI, 산학협력공동연구프로젝트등 - 도우컴퓨팅, ITS, 교보증권

연세대학교 공동연구 교육프로그램개발 연세대수학과 연세대산업공학과정보통계연구실 다학제간공동연구 산학협력프로젝트 연세대수학과 김정훈 ( 확률미분방정식과금융 ) 김해경 ( 통계적금융자료분석 ) 이승철 ( 확률론과금융 ) 연세대경영학과 김주철 ( 금융공학 ) 김학은 ( 화폐금융 ) 조하현 ( 경기변동및리스크 ) ITS 도우컴퓨팅 교보증권

연세연구현황 연구센터정식설립인가는 2008 년 3 월 하지만 1997 년초부터 3 분의교수님들을중심으로금융수학연구시작 금융수학교재출판이승철, 수학과현대금융사회, 2002, 교우사김정훈, 금융수학, 2005, 교우사김정훈, 금융과수학의만남, 2006, 교우사 1998 년부터 SDE 강의 ( 대학원, Oksendal 교재 ) 2000년부터수학과현대사회강의 ( 학부교양과목 ) 2004년부터응용수학 ( 학부금융수학강의 ) 2006 년부터 Levy process 강의 ( 대학원, Applebaum 교재, Cont 교재 )

연세연구현황 금융관련해외학술교류 2004년호주 2005년쿄토 2005년호주 키지마교수초청

연세연구현황 해외학술교류 2006 년 Bacheiler Conference 참석 2008 년 American Option 의대가호주 Zhu 교수님의세미나

연세연구현황 해외학회발표 2007 년게이오대학 SV bond option CEV 모델 SVRS 모델

연세연구현황 국내학회참석 2008 kms 미팅 ( 계명대학교 ) 2008 Kms 확률론워크숍 ( 고려대학교 ) 2008 16 차 ICFIDCAA ( 동국대학교 ) 2008 년금융공동학회참석

연세연구현황 산학협력세미나개최 이하생략 2007년 6월 10일장원재박사 - 삼성증권 2007년 10월 11일정대용박사 - 한국금융연수원 2007 년 11 월 14 일서승석박사 - 한국투자증권 2007년 11월 21일박도현박사 - 한국투자증권 2008년 3월 20일박종곤박사 ITS 2008 년 4 월 16 일배원성박사 - 도우컴퓨팅 2008년 5월 17일김영성과장 신한은행 2008년 5월 30일김종훈과장 한화증권금융공학팀 2008년 7월 4일 Eric Young - 미국Nvida 본사 2008년 7월 11일기호삼박사 KIS채권평가

연세연구현황 세미나관련포스터들

연세연구현황 연세대세미나 7 월 23 일저녁 5 시 호주머큐리대학 장지욱박사님

연세연구현황 병렬컴퓨팅연구현황 수퍼컴퓨터를이용한병렬처리 (Monte Carlo Simulation) - 2006 년 3 월부터 Clearspeed 를이용한병렬처리 (Monte Carlo Simulation) - 2007 년 6 월부터도우컴퓨팅과공동연구진행중 CUDA를이용한병렬처리 (Monte Carlo Simulation) - 2008년 1월부터세미나개최 2008년 6월 12일, 7월 4일, 7월 11일연구결과발표 - KMS 확률론워크숍 6월 13일 ( 서울 ), 16th ICFIDCAA 7월 30일 ( 경주, 예정 ) ieee submit 예정 CUDA 등병렬처리관련대학연구팀, 연구기관및업체들과산학연협력체제및네트워크구축중

2. 기초계산재무및 MC

Introduction for Option Pricing European Call Option 1. asset dyanmics GBM : ds t = μs tdt + σ S tdw t 2. payoff [ S K ] + T Payoff [ S K ] + T K ST 3. option price is Q rτ + C=E [ e [ S K]] t T

r τ + 옵션의현재가치 C=E[ e [ S K ]] t T 직접풀이 Closed form solution C= t S Φ( d ) Ke Φ( d ) r τ 0 1 2 2 x 1 x 2 2 ln( S0 K) + ( r σ 2) Φ ( x) = e dz 2π d1 = 2 1 σ τ τ d = d σ τ PDE 방법 in FDM, FEM, Meshless 2 2 2 f f f 1 2 f f 1 2 + rx + ry + f 2σx + ρσ 2 xσ y + 2σ y = rf 2 t x y x x y y 시뮬레이션방법 Monte Carlo N rτ + 1 rτ E[ e [ ST K] ] = lim e [ ST K] N i N i +

Closed Form solution European Call Option Q rτ + C=E [ e [ S K]] t T 4. By Ito s lemma Q T 1 2 ( r 2 σ ) τ+ σw = BS-PDE : S S e τ ST = S e 0 0 1 2 2 ( r σ ) τ+ σ τn(0,1) 5. By Feynmann-Kac Theorem f + rxf + σ x f = rf 1 2 2 t x 2 xx 6. Closed Form Solution r C= t S0Φ( d1) Ke τ Φ( d2) x 1 x 2 2 Φ ( x) = e dz 2π d 1 2 ln( S0 K) + ( r σ 2) τ = 2 1 σ τ d = d σ τ

새로운구조의상품에대한분석작업 (FDM) 상품설명서 Front (marketer) 2Month Overview of Greek Hedge Simulation Accept or Not Needs veteran quant within few days Hard for junior quant Middle (quant) System FDM code in Matlab or C/C++ FDM code in C/C++ code 1~2 week ( for debugging) Use own library & similar codes Consider boundary conditions 매일반복계산 Hedging ( 매일 ) Front (ELS 운영부서 ) 가격, Greeks 요청 Computer Hedging ( 매일 ) 5-20 sec 이내결과출력 가격, Greeks

PDE method for ELS 2 2 2 f f f 1 2 f f 1 2 + rx + ry + f 2σx + ρσ 2 xσ y + 2σ y = rf 2 t x y x x y y With Boundary Value& Terminal Payoff Domain for 2-Star n-chance Stepdown ELS Step down Worst Perf.

Monte Carlo Simulation Law of Large Number : we can compute expectation N rτ 1 rτ E [ e [ S K ] ] = lim T e [ S T K ] N i N + + S T We can generate any process from given dynamics ds t = μ S t dt + σ S t dw t ds = μs dt + f ( Y ) S dw t t t t t i

Monte Carlo Simulation Why MC is need? Easy to imply 적용이쉽다. Complex structure : path-dependence, prepayment, complex payoff, etc. ELS 등복잡한상품의적용에유리 High demension : multi-asset problems (n>4) MC is the only solution (or sparse grid method) 다자산상품에대한유일한방법임

Monte Carlo Simulation 상품발행시상품거래시 Pricing Pricing Overview of Greek Greeks Search Hedge Simulation VaR계산, 위험관리조기상환확률계산 신상품 Hedging ( 매일 ) Hedging ( 매일 ) Easy for even junior quant 몇시간이내구현 가격, Greeks 요청가격, Greeks 출력 Simple MC coding Computer Excel/VBA, Matlab, C/C++ Library, Rand() 함수이용 debugging

Monte Carlo Simulation N rτ 1 rτ E[ e [ ST K] ] = lim e [ ST K] N i N + + i 6.0000% 01:43.68 4.0000% 2.0000% 0.0000% 01:26.40 01:09.12 N : 10 만번이상시행해줘야함 -2.0000% 00:51.84-4.0000% -6.0000% -8.0000% 00:34.56 00:17.28 실제거래되는 ELS의계산시 10 만번실행에 1 분정도계산시간소요 -10.0000% 500 1,000 5,000 10,000 20,000 50,000 100,000 400,000,000,000 00:00.00 100 개의상품이라면 2 시간이상소요 1 현재국내업계의구현방법 1. 5 만번정도만돌림 2. FDM 등의방법이용

250 time step Path simulation 환경 : Intel CPU 3Ghz 14.8 14.6 14.4 14.2 14 13.8 13.6 13.4 13.2 13 12.8 Black-Scholes Clsoed : 14.23124493415722500 Monte Carlo Simulation : 14.26851272608143400 Error : 0.03726779192420970 Simple MC 의경우 10 만이상이 Simulation 하는것이적당 7.65sec 하지만계산시간의제약으로약 5 만번정도만돌리면... 1000 11000 21000 31000 41000 51000 61000 71000 81000 91000 101000 111000 121000 131000 141000 151000 161000 171000 181000 191000 Why MC is not used? Most contracts(95%) can be solved without MC. (closed, FDM) Computation Time : Too slow to get accurate results -1 minutes for each pricing. 4 minutes for greeks 100 contracts : 7 hours to comutes (1 day : 6 hours) 시나리오분석용 Greek plot 그리려면하루종일걸림 병렬화 Unstable sensitivity : non-smooth greeks plot

Reasonable Solutions to speed up MC 1. New theory in convergence Malliavin Calculus, Operator Technique, Asymptotics 2. Fast pseudo & quasi-rngs, Transformation 3. Control Variate, Variance Reduction 4. Using Powerful Computer 5. Parallel Computing 1주제 HPC(use many CPUs) - OpenMP(SMP), MPI (Cluster) Alternative Method - IBM Cell BE, ClearSpeed, GPGPU(CUDA) 2주제 3주제 이상적모델 :1234 1,2,3.4 를먼저실시하고 5 에관심을갖는다.

Pseudo vs. Quasi 1 1 0.8 0.8 0.6 0.6 0.4 0.4 0.2 0.2 0 0 0 02 0.2 04 0.4 06 0.6 08 0.8 0 1 0.2 0.4 0.6 0.8 1 본 발표에서는 생략 3 4 2 3 2 1 1 0-4 -3-2 -1 0-1 -2-3 -4 LCG32 1 2 3 0 4-4 -3-2 -1-1 0 1 2 3 4-2 -3 3-4 Halton Sequence

3. 병렬처리 (pmc) 에대한이해

HPC 와분산처리의차이 병렬처리는크게 3 가지로나뉘는데 하나의방법은 HPC 로, 하나의작업을여러개로쪼개어계산하도록함으로써계산시간을단축시킴 다른하나의방법은여러개의작업을여러개의서버에분산처리시켜전체작업시간을단축시키는기법 웹서버, 게임서버에사용되는로드벨런싱도분산처리기법의하나임 계산의관점에서병렬처리는 HPC 를의마함 분산처리의예하나의자산당 200초걸리는자산 200개가있다. 총 40000초걸림 200개의서버에서각자산정보를보내서돌린결과를받음 병렬처리할필요없이 200초만에모든 VaR 계산 Quant에게유리 ( 다시코딩할필요없음 ), 회사입장비용문제 ( 수십억원 )

금융권에서의병렬화진행상황 일반프로그래밍 Excel/VBA 혹은 C/C++ 금융프로그래밍 Excel2007 에서 excel 내장함수가아닌 Excel/VBA, C/C++ 을사용하면오히려속도가느려지는현상이발생하는경우가있음 (excel 에서 cell 단위자동분산처리함 ) 분산처리여러명이동시에작업을수행함, 혹은여러대의컴퓨터가동시에여러작업을수행함서버가알아서처리하므로 Quant는신경쓸필요없음현재많은중소형증권사 (4년전대부분금융권 HPC컨퍼런스 Intel 한국지사부사장曰 ) HPC Cluster기반병렬시스템을구축하였거나구축하려는추세 (ELS 라이센싱대형증권사 ) 외산병렬시스템도입을고려 ( 대형은행 ) 병렬프로그래밍이가능한퀀트필요 인력이절대적으로부족함금융관련대학 : -- 연세대수학과 (cluster구축) 유일비금융대학 : 타전공은많은편임 (CS, 기계등 ) 대안적가속처리 (IBM Cell, CS, CUDA 등 ) 최근관심이높아짐, 하지만, 역시인력부족금융관련대학 : 연세대수학과유일 (CS, CUDA), 해외 (Oxford Univ. ) 비금융대학 : 이화여대그래픽연구실 (CUDA), 각대학컴공, 물리, 천문대기, 기계등

병렬처리 (HPC High performance Computing) 하나의작업을여러개의 CPU(Cores) 로작업을실행시켜계산시간을줄이는방법 Wall Clock Time Task 를병렬처리에의해처리하는데걸린전체시간 Wall Clock Time 1 Original Jobs Parallel Overheads Wall Clock Time 2

몇년기다리면빠른컴퓨터가나오지않을까? 그냥엔터치면결과값이나올텐데.. 지금병렬화를배워서금융에적용해야하나? 현재출시되는모든 CPU 는 Dual Core, Quad 코어기반임 추후출시되는 CPU 는 8 core, 16 core, 32 core 로연산속도증가보다는하나의칩에코어의개수를늘리는방식으로개발되고있음 이러한멀티코어시스템의성능을 100% 발휘하도록하려면 모두병렬프로그래밍을해주어야함.

Application for Massively Parallel MC 신규상품발생시 Front 입장 ELS 발행 마진 Hedge Scenario Price Greek Greeks(T,S1,S2 ) New ELS Parallel MC 속도는 single FDM 보다빠르고개발주기는훨씬짧음 32

Application for Massively Parallel MC VaR 을통한위험관리시 RM ( 위험관리 ) Portfolio Analysis Stress Test VaR Greeks ELS ELS products ELS products ELS products ELS products ELS products ELS products products Parallel l MC 위험관리용계산시간을획기적으로단축시킴 ELW ELW ELW ELW ELW Parallel Tasks 33

Application for Massively Parallel MC 채평사 가격 baord Parallel MC 를사용하여기존 MC의가속화 수많은상품들 ELS ELS products ELS products ELS products ELS products ELS products ELS products products Parallel l MC 34

Parallel MC 구현의용이성 상품설명서 Simple MC coding 비전문가도코딩이가능한가? 쉽게구현가능한가? 코드수정이많이필요한가? 코드재사용이용이한가? 구축비용이많은가? 유지관리가용이한가? parallel l MC coding 과연속도가빠른가? 병렬실행병렬실행병렬실행병렬실행

병렬프로그래밍을위한시스템구축 하드웨어구조

KISTI 수퍼컴퓨터 4 호기 Tachyon 구분 내용 모델명 SUN Blade 6048 블레이드노드 성능 : 24TFlops(Rpeak) 노드 : 188개 ( 컴퓨팅 ) CPU AMD Opteron 2.0GHz 4 개노드당 : 16 Core (Quad Core) 총 : 3,008 개 ( 전체 ) 메모리 32GB( 노드 ) 스토리지 207TB( 디스크 ), 422TB( 테이프 ) 노드간네트워 Infiniband ib 4X DDR 크

HPC in cluster 여러대의 SMP 를네트웍으로연결 Each Nodes has 2-8 CPUs 4~10 Gflops in DP for each CPUs Each Nodes connected by Infiniband, Gigbit Ethernet 1024+ nodes system is possbe possible Support standard OpenMP & MPI library Benefit : develop envirinment, Technical supports from vender PRNGs library for Monte Carlo simulation MC 의경우 1 만배이상속도향상을기대할수있음 : 하지만구축및관리비용이많음 Too expensive 기상청 15Tflops 서버도입비용 200억이상 ( 전기, 쿨링, 공간, 네트웍, 관리자등유지비필요 ) 금융권에필요한성능의서버 HPC for 400 Gflops 서버도입비용 - 수억원이상 ( 유지비, 설치공간등별도 ) IBM, HP 등개발용 8 workstation : 300만원 ~1천만원정도면 whitebox 구축 ( 제작 ) 가능개발용 2 node 2*8 core cluster : 1천만원정도면 whitebox 구축가능

금융권 HPC 용 16 코어 SMP 머신 도입비용약 2000 만원가량 HP ProLiant DL580G5 Rack Type 4U case 사용인텔제온 E7340 CPU 4 개 : 16 코어메모리 8GB Node 당 100Gflops 유지 Tachyon 1 노드와유사한성능 8 노드도입시약 3 억원정도예상됨 성능 : 64 배향상 국내금융권도입 : 비용대비성능향상의미약으로 HPC 도입이잘안됨

수퍼컴퓨터 4 호기 Tachyon on KISTI 구분 내용 계정 SRU 100시간 : 100만원 ( 기업 ) SRU 10 시간 : 10 만원 ( 학생 ) 접속환경 ssh 접속 30분 실행환경컴파일러병렬라이브러리수치라이브러리 CentOS 4.4 - Linux 환경 GCC, PGI Compiler, Intel Compiler OpenMPI IMKL, IMSL 등 계정사용을통해 HPC 도입효과를미리검토해볼수있음

작업노드 ( 프로그래밍, 디버깅 ) Tachyon Server 는 SSH 를통해접속해야하고 30분까지로접속시간이제한되어있음 따라서, 다음의시스템에서 OpenMP, MPI 코딩을작성, 디버깅하고최종결과물은 Tachyon에서실행하는방법을사용한다. 1. Windows XP 환경 (PC) : GUI 환경에서 programming MS Visual Studio 2005+ MPICH2 2. Linux 환경 (server) : linux에서실행테스트 ICC 10.1 + OpenMPI 3. Tachyon Server : 최종코드를 job_batch 실행

SSH 원격접속환경 Windows 환경에서 PuTTY 를통해접속

병렬환경 SMP 머신 : OpenMP 프로그래밍 16coe core 지원 : 2 천만원미만 (16 배성능향상보장 ) Cluster 머신 : MPI 프로그래밍 64 core 지원 : 1 억원미만 : (60 배성능향상보장 ) OpenMP, MPI : ( 무료 ) IMSL, IMKL : 병렬라이브러리 : ( 유료 )

병렬알고리즘 45

Parallel FDM, FEM (matrix) Main For(i=1,i<N,i++){ PE1 PE2 PEn-1 PEn............................ 인접데이터의통신에의한 bottleneck

Parallel MC simulation Main Divide & Conquer For(i=1,i<N,i++){ PE1 PE2 PEn-1 PEn For(i=1,i<N, M){... } For(i=1,i<N, M){... } For(i=1,i<N, M){ For(i=1,i<N, M){...... } } 인접데이터의통신이필요없음 : MC 병렬 scailability 가좋다

Parallel Monte Carlo Simulation in Finance 상품설명서 Easy for even junior quant Simple MC coding Need veteran parallel coder or library Single Code가잘구축되어있고, 병렬라이브러리가구축되어있다면신상품의병렬화는매우쉽다. (openmp 이용시 ) 몇시간이내 Use own Parallel library & similar codes parallel l MC coding 매일반복계산 Hedging ( 매일 ) 가격, Greeks 요청 병렬실행병렬실행병렬실행병렬실행 Hedging ( 매일 ) Tachyon 급수퍼컴퓨터 0.05 sec 이내결과출력 가격, Greeks

LCG32 X ( a X c) mod m n+ 1 = n + M a c Visual C/C++ 2 32 214013 2531011 GNU C 2 32 69069 5 Unix (LCG48) 2 48 25214903917 11 ANSI C 2 32 1103515245 12345 Numerical Recipes 2 32 1664525 1013904223 Period : 2 32-1 = 4294967295 = 4.2 * 10 9 약 42 억개

Parallel RNGs

Split Method for (i=0; i<n-1; i++ ) for (i=istart; i<iend; i++) CPU ID 0 CPU ID 1 CPU ID 2 51

Multiseed Method for (i=0; i<n-1; i++ ) srand48p(123+(1+cpuid)*45); for (i=0; i<chunksize-1; ) CPU ID 0 CPU ID 1 CPU ID 2 52

Leap Frog Method for (i=0; i<n-1; i++ ) for (i=istart; i<n-chunksize-1; CHUNKSIZE ) CPU ID 0 CPU ID 1 53

Problems in Parallel MC LCG : 2^32-1 42 억개 54

Suitability for Parallel Method Multiseed Leapfrog Splitting DC D.C JAh J.Ah. LCG OK OK OK X - RAND48 OK OK OK X - MCG OK OK OK X - Lagged Pibonachi OK OK OK X - MWC OK OK OK X - MT19937 OK X X OK OK Well RNG OK?? OK 55

Dynamic Creation for (i=0; i<n-1; i++ ) Complex dividing for non-overlapping cycle for (i=0; i<chunksize-1; ) CPU ID 0 CPU ID 1 CPU ID 2 56

Jump-Ahead Method for (i=0; i<n-1; i++ ) Divide sequence with GF(2) polynomial for (i=0; i<chunksize-1; ) CPU ID 0 CPU ID 1 CPU ID 2 57

Algorithm for MT19937

smt architecture of MT19937 Initial ii Seed 0 1 2 i i+1 smt Generator Extractor U1 i+m i+m+1 623

MT19937 병렬화 Shared pmt architecture of MT19937 Initial Seed U2 Generator Extractor 0 Generator 1 Extractor 2 U1 i i+1 Parallel pmts With Large StepSize 1cycle generate 624 RNGs i+m i+m+1 623 Generator Extractor Un Share Memory

Parallel smt MT19937 Each Cores execute smt independently We will use this model 0 1 2 0 1 2 0 1 2 i i+1 i i+1 i i+1 i+m i+m+1 i+m i+m+1 i+m i+m+1 623 623 623

Parallel Quasi RNG For Loop Nsim simulation For Loop for T simulation of path Method 1 base p 에의한병렬화 Split Halton with Nsim /16 -- 16 is # of core Core has own Base 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59 Scramble each Sequence with T times Method 2 : 준주기성을고려한 n 병렬화 select large prime such as 23 Compute Split K= Nsim/16 * 24 n=(k*coreid + i) Parallely Compute Halton(23,n) Scrample each Sequence with T times

실제병렬화 신상품, 상품설명서 Excel, Matlab, C/C++ 코딩 싱글코드알고리즘 디버깅 Profile 병렬화시스템결정 계산로드가많이걸리는부분파악 SMP, MPI, CUDA, CSCN, etc 병렬코딩 OpenMP, MPI, Matlab, etc. 실행및디버깅 결과출력

금융문제의병렬화기법 사용방법1 총 M회시뮬레이션을병렬처리각 N 개의 Core 가 M/N 회시뮬레이션실행각 Core가독립적으로 Boxmuller 및 RNG 생성 1/N으로계산시간단축 장점 : single code의 90% 이상그대로사용 방법2 1. RNG 를병렬화하여미리생성 2. N개의시뮬레이션을병렬처리 3. N개의시뮬레이션평균 조기상환시 RNG 생성시간낭비 방법3 Table Technique RNG 를병렬화하여미리생성 (1 회 ) memory에 load하여필요시사용각상품별로 (K 회 ) M/N회의시뮬레이션을병렬처리 모듈화작업시 single code 를그대로사용가능 많은상품을계산해야하는시스템에서적합 1/K*N 으로계산시간단축충분한메모리가확보및분산처리 Memory access bottleneck 발생

Single Code 병렬몬테카를로시뮬레이션예제 1. Full-path 유럽형 Vanilla Call 옵션 : reference & benchmark 용 S : 100, K : 100, r : 0.0303, v : 0.3, T : 1 2. ELS pricing : 삼성증권 1909 호주식연계증권 3 년만기 2 star : POSCO 일반주, S-Oil 12 chance : 디지털옵션 Double Barrier Down barrier : 장중체크 ( 둘중하나라도하락한계 ) Up barrier : 매일종가체크 ( 두개다상승한계 ) Step-down : 없음, 동일한조기상환조건 (Digital Option 형태 ) 지급 : 조기상환시 +2 영업일

4. 수퍼컴퓨터를이용한 parallel Monte Carlo Simulation I OpenMP 를이용한병렬화

OpenMP 개념 메모리를공유한 SMP 머신 (core2 duo 등의형태 ) 에서병렬코딩함. 16 코어머신을이용하면 MC 의경우약 16 배의속도향상기대 C/C++ 언어와 Fortran 언어를지원함 Windows 환경은 Visual Studio 2003 이상에서기본지원 Unix 환경의경우최신버전기본지원 Linux 의경우 GCC 2.4.2 이상에서지원 OpenMP 명령어를통해컴파일러가자동으로병렬화 For Loop 를쉽게병렬화할수있고, 각 Core 가메모리를공유하기때문에병렬코딩이매우편함

SMP 한대의컴퓨터 Shared Memory Core0 Core0 Core0 CoreN-1 CoreN 각코어가모두하나의메인보드위에있기때문에모두같은메모리를사용특별히, 통신코딩을할필요가없음 OpenMP 코딩의편리함

OpenMP 개념 Fork Master Thread 병렬화영역 Join Fork 병렬화영역 Join

OpenMP 병렬화예약어들 omp_set_num_threads(16); 총 16개의 thread 사용설정 totaln=omp_get_num_threads; 전체병렬화개수파악 tid=omp_get_thread_num(); 각병렬프로세서번호인식 #pragma omp 지시어 #ifdef_openmp 순차프로그래밍에서도사용가능하도록프로그래밍 parallel l for critical private() shared() schedule()

OpenMP 예제 1 #include <stdio.h> #include <omp.h> int main (int argc, char *argv[]) { int nthreads, tid; omp_set_num_threads(4); #pragma omp parallel private(nthreads, tid) { tid = omp_get_thread_num(); nthreads = omp_get_num_threads(); printf(" Hello World from Thread %d of %d \n", tid, nthreads); } return 0; } 병렬화영역

OpenMP 병렬화방법 for(i=0; i<m; i++) { a[i] = b[i*n]*c[0]; for( j=1; j<n; j++) a[i] += b[i*n+j]*c[j]; } 자동병렬화 #include <omp.h> #pragma opm parallel for shared(m,n) private(i,j) for(i=0; i<m; i++) { a[i] = b[i*n]*c[0]; [0] for( j=1; j<n; j++) a[i] += b[i*n+j]*c[j]; }

#pragma omp parallel shared(fsum, N) private(tid,fsum_local,nnn) { NNN = 0; fsum_local = 0; tid = omp_get_thread_num(); printf("%d \t",omp_get_num_threads()); #pragma omp for for ( i=0; i< Ni Nsim ;i++ ) { xt1=s; RNG 병렬화코딩필요 xt2=s; for(m=0; m<path; m++) { xx1 = myrand()/(rand_max+1.0);if(xx1==0.0) xx1=0.0000000000001; xx2 = myrand()/(rand_max+1.0);if(xx2==0.0) xx2=0.0000000000001; normal1=sqrt(-2.0*log(xx1 ))*cos(2.0*3.14159265358979323846*xx2 ); xt1= xt1 + r * xt1 * dt +v*xt1*sqrt(dt)*normal1; xt1sqrt(dt) } oprice=max(xt1-k,0); fsum_local =fsum_local+ oprice; //printf("%f",op); } #pragma omp barrier #pragma omp critical (update_sum) { fsum +=fsum_local; stop=clock(); printf("\n%d \t %20.17f \t %20.17f \n",tid,fsum, fsum_local) ; } } // end of OpenMP results = (double) 1/Nsim * exp(-1* r * tau)* fsum; stop=clock(); htime = 0.001*difftime(stop,start); //windows printf("\n%19.17f \t %19.17f %7.5f \n",results,results-bsp, htime) ; Loop 병렬화부분 결과 Reduction 부분 전체병렬화영역

수퍼컴퓨터 Tachyon OpenMP job batch scheduler 282% [e063rhg@tachyond e063rhg]$ vi a.sh #!/bin/bash #$ -V #$ -cwd #$ -N openmp_job #$ -pe openmp 4 #$ -q small #$ -R yes #$ -wd /work01/e063rhg/ #$ -l h_rt=00:01:00 000100 #$ -M myemailaddress #$ -m e export OMP_NUM_THREADS=4 /work02/e063rhg/omp.exe >result.txt

Job scheduler 에서대기중인사람들 예상실행시간 40 sec 의 job 을약 40 분기다려야함 Scheduler 조정을통해제일적게기다리는편

Tachyon idle core 현황 6 월 30 일부터현재까지계속 job 이 waiting 상태로, 수퍼컴퓨터사용의의미가없음 OpenMP, MPI test 불가

Job Schedule 실행된모습 ================================= Black-Scholes : 14.23124493415723357 1 3-1073749904 566413.67638386972248554 566413.67638386972248554 3-1073749904 1132306.36511257803067565 565892.68872870830819011 3-1073749904 1701503.34236495988443494 569196.97725238185375929 3-1073749904 2254231.80765507556498051 552728.46529011556413025 14.29527750057961200 0.06403256642237842 elapsed time is 44.892820

OpenMP 결과 1. 수퍼컴퓨터에서는 1~16 배까지 core 개수를늘리면 scailability 가증가 2. 유휴 CPU 가부족하여 scailability 를테스트하기어려웠음. 3. CUDAp, MATHp, WindowsPC 등에서 1~4 core 기반의 scailability 쉡게체크가능 4. 간단히 rand() 함수를이용한 loop 병렬화시오히려속도감소 memory bank conflict, shared static variable 문제

5. 수퍼컴퓨터를이용한 병렬 Monte Carlo Simulation II MPI 병렬화

Cluster 전체시스템 Network 하나의노드 하나의노드 Core0 CoreN Core0 CoreN Shared Memory Shared Memory 각노드에서각각프로그램을실행해줘야함 (mpirun) 각노드의메모리는서로공유하지않으므로서로통신해줘야함 MPI 코딩의복잡함

MPI 개념 MPIRUN MPI로병렬프로그래밍된실행명령을각각의 node에복사하여각각의노드가병렬명령을실행할수있도록지원함 MPI setting 에각각의 node 설정을해주어야함 : 관리의복잡성발생 각 Node는네트웍을통해연결되어있으므로, 서로메모리를공유하지않음. 각메모리는서로독립적으로작동하므로 PDE solving, Matrix 병렬화등에서는서로의메모리정보를서로통신을통해업데이트해줘야함 MPI 는병렬화보다는오히려통신프로그래밍을쉽게해준역할을함. OpenMP 와는다르게프로그래머가병렬화작업, 메모리공유를직접해줘야함 MPIEXEC, POE 등의 MPI Launcher 를통해실행해줘야한다. 전용서버의경우 scheduler 대신 plink 를활용하면유용하다.

MPI 예제 1 #include <stdio.h> #include "mpi.h int main(int argc, char *argv[]) { int rank, size; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD,&rank); MPI_Comm_size(MPI_COMM_WORLD,&size); printf("hello, world I am %d rd core of %d core system\n",rank,size); } MPI_Finalize(); return 0;

MPIexec 다음은 mpiexec 를통해 core 를 1 개, 2 개 4 개로확장시켰을때의실행결과를나타내고있다.

Job 분할방법 How do we divide job ( FOR LOOP)? ID=0 ID=1 ID=2 ID=3 ID=0 ID=1 ID=2 ID=3

Loop 분할방법들 단순분할 for (i = 0; i < Nsim/N; i++) {. } 1 3 순환분할 for (i = Tid; i < Nsim; i+= N) {. } Block 분할 블록 - 순환분할 2 i_start = Tid * (Nsim /N); i_end = i_start + (Nsim /N); if (Tid == (N-1)) i_end = N; for (i = i_start; i < i_end; i++) {. } 4 for (i = n1*block*myrank; i < n2; i+=nprocs*block) { } for (j = jid; j < min(ij+block-1); i+=n2n) {.

para_range(n1,n2,n3,n4,n5,n6) 함수 Para_range 함수는크게 3가지의병렬화방법중 Method 2의기법으로 For Loop를균등분할함 void para_range(int lowest, int highest, int nprocs, int myrank, int *start, int *end) { int wk1, wk2; wk1 = (highest - lowest + 1) / nprocs; wk2 = (highest - lowest + 1) % nprocs; *start = myrank * wk1 + lowest + ( (rank<wk2)? myrank : wk2); *end = *start + wk1-1; if(wk2 > rank) *end = *end + 1; } N ai () n1 1 i= 1 i= = ai () + n 2 ai () + + ai () i= n 1 2 + i nk 1 1 N = + Core 0 Core 1 Core k-1

MPI 예제 2 ( MPI 통신 ) #include <mpi.h> #include <stdio.h> #define n 100000 void para_range(int, int, int, int, int*, int*); int min(int, int); void main (int argc, char *argv[]){ int i, nprocs, myrank ; int ista, iend; double a[n], sum, tmp; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); para_range(1, n, nprocs, myrank, &ista, &iend); for(i = ista-1; i<iend; i++) a[i] = i+1; sum = 0.0; 0; for(i = ista-1; i<iend; i++) sum = sum + a[i]; MPI_Reduce(&sum, &tmp, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); sum = tmp; if(myrank == 0) printf("sum = %f \n", sum); MPI_Finalize(); }

MPI 예제 3 Pi 계산 #include <math.h> #define n 100000 main(){ int i,istep,itotal[10],itemp; i i i double r, seed, pi, x, y, angle; pi = 3.1415926; for(i=0;i<10;i++) itotal[i]=0; seed = 0.5; srand(seed); for(i=0; i<n; i++){ x = 0.0; y = 0.0; for(istep=0;istep<10;istep++){ r = (double)rand(); angle = 2.0*pi*r/32768 r/32768.0; x = x + cos(angle); y = y + sin(angle); } itemp = sqrt(x*x + y*y); itotal[itemp]=itotal[itemp]+1; t t ] } } for(i=0; i<10; i++){ printf(" %d :", i); printf("total=%d\n",itotal[i]); } #include <mpi.h> #include <stdio.h> #include <math.h> #define n 100000 void para_range(int, int, int, int, int*, int*); int min(int, int); main (int argc, char *argv[]){ int i, istep, itotal[10], iitotal[10], itemp; int ista, iend, nprocs, myrank; double r, seed, pi, x, y, angle; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, COMM &myrank); para_range(0, n-1, nprocs, myrank, &ista, &iend); pi = 3.1415926; for(i=0; i<10; i++) itotal[i] = 0; seed = 0.5 + myrank; srand(seed); for(i=ista; i<=iend; i++){ x = 0.0; y = 0.0; for(istep=0; istep<10; istep++){ r = (double)rand(); angle = 2.0*pi*r/32768.0; x = x + cos(angle); y = y + sin(angle); } itemp = sqrt(x*x + y*y); itotal[itemp] = itotal[itemp] + 1; } MPI_Reduce(itotal, iitotal, 10, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); for(i=0; i<10; i++){ printf(" %d :", i); printf(" total = %d\n",iitotal[i]); } MPI_Finalize(); }

MPI 예제 4 ( Full Path 유렵형 Vanilla Call 옵션 ) for ( i=0; i< Nsim ;i++ ) { xt1=s; xt2=s; for(m=0; m<path; m++) { xx1 = rand()/(rand_max+1.0);if(xx1==0.0) xx1=0.0000000000001; xx2 = rand()/(rand_max+1.0);if(xx2==0.0) xx2=0.0000000000001; normal1=sqrt(-2.0*log(xx1 ))*cos(2.0*3.14159265358979323846*xx2 ); xt1= xt1 + r * xt1 * dt + v*xt1*sqrt(dt)*normal1; } oprice=max(xt1-k,0); fsum =fsum+ oprice; } results = (double) 1/Nsim * exp(-1* r * tau)* fsum; stop=clock(); htime = 0.001*difftime(stop,start); //windows printf("\n%19.17f \t %19.17f %7.5f \n",results,results-bsp, htime) ; Loop 분할필요 병렬 RNG 필요 multiseed method MPI reduce 필요

MPI 화코드 #include <mpi.h> #include <stdio.h> #include <math.h> #define n 150000 void para_range(int, int, int, int, int*, int*); int min(int, int); main (int argc, char *argv[]){ int i, m; int ista, iend, nprocs, myrank; double r, seed, pi, x, y, angle; Nsim = n; 금융관련변수설정은모두생략함 (single 코드와동일 ) 병렬화블록 MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); MPI_Comm_rank(MPI_COMM_WORLD, &myrank); para_range(0, Nsim, nprocs, myrank, &ista, &iend); Multiseed 방법사용 seed = 0.5 + myrank; srand(seed); for ( i=ista; i< iend ;i++ ) { xt1=s; xt2=s; for(m=0; m<path; m++) 상황에따라추가적 RNG 코딩 { xx1 = rand()/(rand_max+1.0);if(xx1==0.0) xx1=0.0000000000001; Single code 그대로사용 xx2 = rand()/(rand_max+1.0);if(xx2==0.0) xx2=0.0000000000001; normal1=sqrt(-2.0*log(xx1 ))*cos(2.0*3.14159265358979323846*xx2 ); xt1= xt1 + r * xt1 * dt + v*xt1*sqrt(dt)*normal1; } oprice=max(xt1-k,0); fsum_local =fsum_local+ oprice; } Core간데이터통신 MPI_Reduce(&fsum_local, &fsum, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); MPI_Finalize(); results = (double) 1/Nsim * exp(-1* r * tau)* fsum; printf(" Option Price : %23.17f " results); }

Tachyon : all node is full

MPI 결과 수퍼컴퓨터센터의 tachyon, nobel 서버모두 busy 연세대학교수학과 PDE 팀 4 node 8 core server kisti Hamel Cluster (5 년이상된 Cluster 로성능이많이떨어지만사용자적음 ) 에서테스트 Linear Scailability : CPU 개수와속도향상의선형성이보장됨 ( 단, 병렬 RNG 코딩을해줘야함.) 2. Monte Carlo Simulation 은병렬화의 Scailability 가매우좋은편임 N 개의 Core 사용시 1/N 으로계산시간단축효과, 1/sqrt(N) 의정확도향상 현재의정확도를유지하면서속도를향상시킴 : 1/N

수퍼컴퓨터를이용한몬테카를로병렬화 1. 계산전용서버는자체구축필요 (KISTI 의경우 Job schedule : 최소 30 분 ) 2. MPI의경우직접병렬코딩을하고, MPIRUN을실행해줘야하지만잘만들어진 single 코드가존재하는경우몬테카를로병렬화는어렵지않다. 3. 병렬화를통한속도향상 200초걸리는시뮬레이션문제의경우 2노드 32 core system 구축시 6.3초 0.5억원 8노드 128 core system 구축시 1.6초 2억원 + 알파 16노드 256 core system 구축시 0.8초예상됨 4억원 + 알파 32노드 512 core system 구축시 0.4초예상됨 8억원 + 알파 32 노드의사용시 MC 의편리함과 FDM 수준의속도를얻을수있음 Parallle Quasi MC 를사용할경우 8 노드정도로 FDM 수준의속도향상예상됨

대안적방법

대안적방법 PC 용 CPU 는계산위주이아닌범용으로개발됨 계산위주란? 빠른처리속도와더불어 CPU 내부의 On-chip 메모리가큼여러개의명령을동시에실행, ALU, FP 연산용모듈이많이내장 Intel 은내부메모리를줄인저가버전등등을출시 ( 가격경쟁을위해 ) 따라서, 계산에최적화된하드웨어를통한병렬화기법이최근 HPC 업계에주목받고있음. 대표적인예가 IBM Cell BE, Clearspeed, GPGPU 등임

대안 1 IBM BladeCenter QS20, QS21, QS22 Each Nodes has 3.2Ghz Cell BE processor One Cell BE has 8 SPE units for computing QS20 : 204 Gflops in SP, 21 Gflops in DP QS21 : 408 Gflops in SP, 42 Gflops in DP QS22 : 460 Gflops in SP, 217 Gflops in DP QS21 : 5 Tflops in SP/ 588Gflops in DP in for blade chassis Cell BE CPU ws developed for PS3 The initial target of Cell BE is entertainment it does not need DP, so Cell BE provides very limited double precision in QS20, QS21, but QS22 support DP with 5 times fast. IBM use this artitecture for building next generation world fastest super computer Roadrunner Project. 10X faster than normal CPU based cluster 하지만, 고가임. Cell BE SDK 개발자거의없음 - 금융뿐만아니라국내 CS 분야에도극소수 - 게임개발분야에극소수종사

대안 1 Mucury Cell Accelerator 2.8Ghz Cell BE processor in board One Cell BE has 8 SPE units for computing Cell BE processor at 2.8 GHz SP 180 GFLOPS in PCI Express accelerator card PCI Express x16 interface with raw data rate of 4 GB/s in each direction Gigabit Ethernet interface 1-GB XDR DRAM, 2 channels each, 512 MB 4 GB DDR2, 2 channels each, 2 GB 162W for each board

대안 2 ClearSpeed CSe620 Accelerate Board Acceleration Board for HPC Parallel l 192= 2* 96 PE 66 GFlops in Double Precision Support standard C/C++ SDK Using CSCN compiler 15W per each board cheaper than normal cluster solution 4 board system : 300Gflops 전력소모가작고, 비교적발열이적어 PC, 4U 서버등에쉽게장착가능

대안 2 CATs with ClearSpeed CS announce CATs in SC07 spec 12 CS board in 1U rack Power : total 550W 12* 192 Pes = massively parallel 1 DP Tflops 하나의서버에최대 12 개의카드장착가능

대안 3 Nvidia Tesla C870, D870, S870 Computing by GPU Nvidia 8800GTX chipset Parallel 128 Stream Processors in one chip 500 GFlops in Single Precision C870 : 1GPU in board D870 : 2 GPUs in case S870 : 4 GPUs in 1U chassis Today s 3 번째 Topic Support standard C/C++ SDK CUDA C870 system SP 500Gflops : 70 만원 C870 4board system SP 2Tflops : 300 만원 + PC 비용 S870 4GPUs system SP 2Tflops : 600 만원 + 서버비용 Cheap & powerful solution

6. 대안적방법론 I Clearspeed 가속보드를이용한병렬 Monte Carlo Simulation Co-work with 도우컴퓨팅

사용환경 연세현재 Clearspeed CSe620 보드 1 대를통해병렬시뮬레이션테스트중환경 : Windows XP + Visual Studio 2005+ CSCN 컴파일러 + CSCN SDK C 언어의확장으로 mono, poly 라는병렬명령어셋을통한병렬화를해줘야함 Reference site : 옥스포드대학에서 LIBOR 쪽연구

상품종류 2Star Step Down( 원금비보장형 ) 기초자산 삼성전자 (005930) 보통주, SK 텔레콤 (017670) 보통주 청약기간 2008 년 01 월 24 일 ~ 01 월 24 일오후 1 시까지 청약단위 100 만원이상 10 만원단위 판매한도 10 억원 수익발생요건매 6개월기초자산의평가가격이기준가격의 90/90/85/85/80/80% 이상인 ( 종가기준 ) 경우 수익발생기회 만기상환포함총 6 회 최초기준가격결정일 2008 년 01 월 24 일만기평가일 2011 년 01 월 18 일 조기상환평가일 최초기준가격결정일이후매 6 개월 발행일 2008 년 01 월 24 일만기일 2011 년 01 월 24 일 (3 년만기 ) 조기상환수익률 8.1% X n 차 ( 연 16.2%) Knock In 배리어최초기준가격 X 60% 최대가능수익률 48.6% 최대가능손실률 -100% Simulation method Method Generating path Monte Carlo simulation G B M (Geometric Brownian Motion) normal distribution Method of generating normal distribution ib i Box-Muller method #of generating path 50000 이상 ( 기준 100224 개로작성 ) # of Trial (simulation Number) daily trial # of SIMD board Ui Using 1~2 2boards 본자료는 도우컴퓨팅에서제공한 ppt 입니다.

Development Aim & status 운영현황 Base 1. ELS (3년조기상환형6 month) 2. 2 Stock Step Down (redeemable Type) 3. knock in barrier 기초자산 60% 4. pricing engine : MC, FDM (SOR type) 5. 개별평가 Running time 50 sec 이상 6. 운영개발상품 50개 7. 사용자운영환경 Windows, C++, Excel 목표 1. 개별 pricing 시간단축 2. 운영개별상품 50개의pricing time 단축 3. 사용자환경유지 : develop platform: c++ 이용환경 :excel base 4. DBMS 를통한 data 중앙관리 5. ELS 2 stock step down 가속화 6. Hi five 형가속화 7. Single stock ELS 개발 8. 가속 Pricing 모델개발 (ASIAN option etc) 적정 pricing engine 선정 (5배이상 ~10 배속도증가 ) 6 sec ~ 3sec 이내 target instrument simulation method Cal. time Performance 2 stock step down MC 46.23 1 (daily observe, # of path 10224) 17.813 2.59 (out put :price, 4 Greek value) 4.562 10.22 gamma 1,2 6.906 13.2 delta 1,2 3.21 14.4 1.82 25.4 본자료는 도우컴퓨팅에서제공한 ppt 입니다.

1. 2 Stock Step Down 2. 2 Stock Hi-Five 50 45 40 35 30 46.23 1300% 25 Speedup 20 15 10 5 0 3.5 2500% Speedup 1.82 1 CPU core 1 x CSX620 2 x CSX620 300 250 200 150 100 50 0 273.28 2200% Speedup 12.73 4400% Speedup 6.172 1 CPU core 1 x CSX620 2 x CSX620 1 CPU core 1 x CSX620 2 x CSX620 결과 46.23 초소요 3.5 초소요 1.82 초소요 1 CPU core 1 x CSX620 2 x CSX620 결과 273.28 초소요 12.73 초소요 6.172 초소요 13 배 25 배 22 배 44 배 3.0 GHz Intel Xeon 5130(Woodcrest) Dual core System Base 본자료는 도우컴퓨팅에서제공한 ppt 입니다.

Lookback Cliquet Option 50 45 40 35 30 25 20 15 10 5 0 45.1 1300% Speedup 3.24 2400% Speedup 1.82 1 CPU core 1 x CSX620 2 x CSX620 1 CPU core 1 x CSX620 2 x CSX620 결과 45.1 초소요 3.24 초소요 1.82 초소요 3.0 GHz Intel Xeon 5130(Woodcrest) Dual core System Base 본자료는 도우컴퓨팅에서제공한 ppt 입니다.

target instrument simulation method calculation time performance Asian option (path # 152600) MC 7.115048 serial 1 0.153944 1board 47.4 0.110532 2 board 64.4 배 Asian option (path # 384000) MC 16.966 serial 1 0.326242 1 board 58 0.196844 2 board 85 배 European option MC 5.065038 serial 1 (path # 1536000) 0.135237 1 board 37.4 0.098936098936 2b board 51.68 배 look back cliquet option MC 45.1 serial 1 monthly observe, # of path 1920000 3.24 1 board 13 1.82 2 board 24 배 2 stock step down MC 46.23 serial 1 (daily observe, # of path 100224) 3.5 1 board 13.2 (out put :price 4 Greek value) 182 1.82 2board 25.4 배 2 stock Hive Five MC 273.28 serial 1 (daily observe, # of path 96000) 12.73 1 board 21.46 (out put :price 4 Greek value) 6.1720 2 board 44.27 배 3.0 GHz Intel Xeon 5130(Woodcrest) Dual core System Base 본자료는 도우컴퓨팅에서제공한 ppt 입니다.

7 대안적방법론 II CUDA를이용한병렬몬테카를로시뮬레이션

CUDAp workstation at Yonsei Math-Finance Lab 계산용서버 : Fedora Linux + Intel Compiler + CUDA Tesla C870 3 개장착 : 이론상 SP 1.5Tflops in SP : 500 만원이하 Tesla D870 1 대추가도입예정 보조용워크스테이션 Windows XP + Visual Studio 2003 + CUDA Tesla C870 1 개장착 : 이론상 SP 0.5Tflops in SP 비교 Kisti 수퍼컴퓨터 4 호기 : 전체 : DP 24Tflops : (40 억원이상 ), 하나의노드 : DP 0.1Tflops : 2 천만원이상

G80 Device in Tesla Inner Processors execute computing threads Thread Execution Manager issues threads 128 Thread Processors grouped into 16 Multiprocessors (SMs) Parallel Data Cache (Shared Memory) enables thread cooperation Host Input Assembler Thread Execution Manager Thread Processors Thread Processors Thread Processors Thread Processors Thread Processors Thread Processors Thread Processors Thread Processors Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Parallel Data Cache Load/store Global Memory

G80 Device In Tesla H/W Device 3 Device 2 SM SM Cache Device SM Cache1 SM Device Cache 0 SP SP SP SP Shared SM Memory Cache Shared SM Memory Cache Shared SM Cache Shared SM SPMemory Cache Shared SMSP Cache SP SP Shared SM SP SP SPMemory Cache SP SP SFU SP SP SP SFU Cache Shared SP SP Shared SP SP SP SP SFU SP SP SP SFUMemory SP SP SP SP SFU SFU SP Shared SP SP SP SP SFU SFU Memory Shared Memory SM SM Cache SM Cache SM Cache Shared SM Memory Cache Shared SM Memory Cache Shared SM Cache SP Shared SM SPMemory Cache SP Shared SMSP Cache SP SP SP Shared SM SP SP SPMemory Cache SP SP SP SFU SP SP SP SFU Cache Shared Memory SP SP Shared SP SP SP SP SP SFU SP SP SP SFU Memory SP SP SP SP SP SFU SFU SP Shared SP SP SP SP SFU SFU Memory Shared Memory SP SP SP SP SFU SP SP SFU SP SP SFU SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SP SP SFU SFU SP SP SP SP SP SP SP SFU SFU SP SP SP SP SP SP SP SFU SFU SP SP SP SP SP SP SP SFU SFU SP SP SP SFU SP SP SP SFU SP SP SP SFU SP SP SP SFU SP SP SP SP SFU SP SP SP SP SFU SP SP SP SP SFU SP SP SP SP SFU SP SP SP SP SP SP SP SFU SFU SP SP SP SP SP SP SP SFU SFU SP SP SP SP SP SP SP SFU SFU SP SP SP SP SP SP SP SFU SFU SP SFU SFU SFU SFU SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SP SP SFU SP SP SP SFU SP SP SP SFU SP SP SP SFU SP SP SP SFU SP SP SP SP SP SP SP SP Global Memory SP SP SP SP SP SP SP SP SP SP SP SP Global Memory Global Memory Global Memory

SDK architecture Host Device Grid 1 Threads blocks for SMs Kernel Block Block 1 SM launch Waps of fthreads (0, 0) (1, 0) (2, 0) Block (2 0) Block (0, 1) Block (1, 1) Block (2, 1) Grid 2 Kernel 2 Block (1, 1) Thread (0, 0) Thread (1, 0) Thread (2, 0) Thread (3, 0) Thread (4, 0) Thread Thread Thread Thread Thread (0, 1) (1, 1) (2, 1) (3, 1) (4, 1) Thread (0, 2) Thread (1, 2) Thread (2, 2) Thread (3, 2) Thread (4, 2)

CUDA compiler

CUDA syntax Function_name <<<a, b, c>>>(variables ) CuMalloc(A,size) CuMemcpy(A,B,method) global function (variable) { } device function (variable) { } share variable; global variable;

CUDA algorithm example single void add_matrix ( float* a, float* b, float* c, int N ) { int index; for ( int i = 0; i < N; ++i ) for ( int j = 0; j < N; ++j ) { index = i + j*n; c[index] = a[index] + b[index]; } } int main() { add_matrix( a, b, c, N); } CUDA global add_matrix ( float* a, float* b, float* c, int N ) { int i = blockidx.x * blockdim.x + threadidx.x; int j = blockidx.y * blockdim.y + threadidx.y; int index = i + j*n; if ( i < N && j < N ) c[index] = a[index] + b[index]; } int main() { dim3 dimblock( blocksize, blocksize ); dim3 dimgrid( N/dimBlock.x, N/dimBlock.y ); add_matrix<<<dimgrid, dimblock>>>( a, b, c, N ); }

Single Precision vs. Double Precision Single Precision : 32bit double Precision : 64bit Error : 24 mantisa Error : 24 mantisa 10^-7 10^-15 15 Round-off errors in single precision (example in Knuth) (11111113. [+] - 11111111.) [+] 7.5111111 = 2.0000000 [+] 7.5111111 = 9.5111111. 11111113. [+] (- 11111111. [+] 7.5111111) = 11111113. [+] - 111111103. = 10.000000. 000000 Financial Monte Carlo simulation use math function of sqrt, ln, exp, sin, cos or numerical approximation for transformation and cdf Random number generator use divide In this situation, with 10^-7 rounding we will generate same r.v. in different values and lose the accuracy But, in Financial Industry, they allow 1BP in Hedge Vol : that means they allow 10^-4 errors in price. If we can control the errors 10^-5 in single precision in MC. (not FDM, FEM)

Implementation ti for pmc on CUDA

Massively pmc (H/W) 다양한문제를고민해줘야함 RNG 자체의분석필요 (SMT19937 분석 ) 비금융적문제임 Parallel H/W 에관련된문제가대부분 Knuth, the art of computer programming

CUDA 방법 I -- PMT19937 Core 1 y0,0 y0,1 0 1 2 i i+1 Core 0 y0,2 y1,2 Core 2 y1,0 y127,0 y1,11 y127,1 y127,2 i+m i+m+ 1 623 Global Memory Core 127 Global Memory

CUDA 방법 II -- PMT19937 각 16 Block 은 Multi Seed 이용 y0,0 y1,0 y0,1 y127,0 y1,11 y0,2 y127,1 y1,2 y127,2 0 1 2 0 1 2 cores cores i i+1 i+m i+m+ 1 cores cores i i+1 i+m i+m+ 1 623 Shared Memory 623 Shared Memory Global Memory

CUDA 방법 III -- parallel SMT 각 128 SPs 가 Multi Seed 이용 0 1 2 0 1 2 i i+1 i i+1 cores i+m i+m+ 1 cores i+m i+m+ 1 623 Global Memory 623 Global Memory

New approach for massively parallel SPMD 1. Job split method Simulate Option Price in Outer Loop. each simulation, call RNG it has big overheads of function call Wall Clock Time >> Simulation Time / (# of cores) 2. Pre-generation method generate full # of U R.V. for simulation Transfer U R.V. to N R.V. each simulation, they use R.V.s which were already generated. limit of memory bandwidth : 60GB/s : needs 0.025 sec for 1.5GB limit of memory size : 2억개의 R.V.s /each device Wall Clock Time = Simulation Time / (# of cores) + Memcpy Time 3. Avoid Round-off Errors 1 M 1 Nk rτ rτ E[ e [ ST K] ] e [ ST K] i M k N k i + +

New approach for massively parallel SPMD 4. Mixed Precision Method (float-float approach) emulate double precision with two single precision operation DP is 4~10 times slower than SP. DP RNGs much more slower than SP RNGs - same period but : 24bit or 48bit mantisa in SP, 54bit mantisa in DP -heavy function cto call of ln,,s sin,,cos in Box-muller ue 5. Mixed Precision Method (GPU-CPU approach) use 64bit CPU FP in DP computation It need comuniticating between Host and Device. DP in CPU is slower than DP in GPU Tt is easy to imply 6. Fixed-Point Method convert float point data to integer data. ALU is faster than FP Fixed Point Method is useful in LCG, but is not suitable in Box-muller

New approach for massively parallel SPMD 7. Inter-correlation between parallel cores split wthout careful considering, the inter-correlation between parallel cores occure. To avoid this, we need to parallelize with considering algorithms of RNG for different RNGs, we apply different method of parallelizations 8. Overlapping in splitted random sequence Pseudo RNGs has limited period such as 2^31, etc. In massively yparallel generating, g each stream of random number may overlapp with each others. To avoid this, use long period RNGs or dynamic creation method.

Benchmark for RNGs with CUDA Rand48() + Memcpy(DtoH) Size: 122880000 random numbers CPU : 최신 AMD 페놈 2.5Ghz GPU : Tesla C870 CPU rand48 time : 2260.000000 ms Samples per second: 5.2512821E+07 GPU rand48 time : 20.000000 ms Samples per second: 6.144000E+09 속도향상 : 최대 113 X Thread 에따라 80X 정도 Copying random GPU data to CPU time : 540.000000 ms 127

Benchmark for RNGs with CUDA MT19937 + Box-Muller + Memcpy Size: 122880000 random numbers CPU MT19937 RN generation time: 1460.000000 ms Samples per second: 8.4164384E+07 Size: 122880000 random numbers GPU MT19937 RN generation time : 199.955994 ms Samples per second: 6.145352E+08 속도향상 : 7.3 X 원래 MT 알고리즘이 LCG 보다속도빠름 LCG 2260ms vs. MT 1460ms 그런데가속화성능은 LCG가더좋음 LCG 113X vs. MT 24X LCG 20ms vs. 48ms Generated samples : 100007936 RandomGPU() time : 47.960999 ms Samples per second: 2.085193E+09 속도향상 : 24.7 X 128

Occupacy for thread & Performence <<<16,256>>> 129

Performance from Operation Cycles & latency Operation type conversion : 4 cycle float add/mul/mad : 4 cycle floating div : 36 cycle integer add, bit operation : 4 cycle integer comare, min, max : 4 cycle integer mul : 16 cycle Memory 4 cycles for issuing a read from global memory 4 cycles for issuing a write to shared memory 400~600 cycle for reading a float from global memory Need thread schedule strategy

Benchmark for European Vanilla GPU MT19937 RN generation time : 199.955994 ms Samples per second: 6.145352E+08 GPU BoxMuller transformation time : 98.652000 ms Samples per second : 1.245591E+09 Copying random GPU data to CPU time : 517.033020 ms GPU Monte-Carlo simulation... Total GPU time : 56.948002 ms Options per second : 1.755988E+01 Total : 872.589 ms = 0.8 sec Non-full path generation 131

Implementation on ELS pricing and hedging 상품설명서 : 삼성증권제 1909 호주식연계증권 3 년만기 2 star : POSCO 일반주, S-Oil 12 chance : 디지털옵션 Double Barrier Down barrier : 장중체크 ( 둘중하나라도하락한계 ) Up barrier : 매일종가체크 ( 두개다상승한계 ) Step-down : 없음 지급 : 조기상환시 +2 영업일

Excel 화면

Excel/VBA Pseudo code for ELS (single) Parameter 입력 Loop 10만번 ~ 50만번 XT simulation 실행 Boxmuller, RNG(SMT19937) ELS pricing Routine IF문을통해조기사환, 만기조건고려조기상환시시뮬레이션정지 평균값을구함 결과출력

CPU single 실행속도 엑셀 : 50만번시뮬레이션 (Pricing만) : 약 4~5분 ( 조기상환되었는데도느림 ) Excel이실행되는 CPU는성능이안좋음. 시스템 : Intel Core2Duo 2.0Ghz dual core (but single using) ( 장중모니터링 6회실시 ) 즉 50만번시뮬레이션시총사용 RNG 개수 :500000*250*3*6*2 = 4500000000 개 : 45*10^8 조기상환이되도계속 RNG 를생성시킨경우 ( 비교를위해 ) C MT19937 이용시최적화최적화중 RNG BM 변환 CPU 53 초, GPU1 7.3 초, GPU2 2.1 초 CPU 20 초, GPU1 3.6 초, GPU2 1.1 초 Copy CPU 0 초, GPU1 18.3 초, GPU2 6.2 초 MC CPU 18 초, GPU1 1.2 초, GPU2 0.4 초 총 90 초, 30 초 (2.5 배 ) 9.8 초 (9 배 ) 7.1 초 (12 배 ) C 언어 :AMD 페놈 2 5Ghz GPU : Tesla C870

CPU single 실행속도 대부분 1-2 회차에서조기상환됨 총사용 RNG 개수 : 500000*120*6*2 = 약 720000000 개 전체계산량의 1/6 로감소 : 이론상 CPU 에서 15 sec 가능?? 불가능함. 원인 : Function call 에의한오버헤드 (IF 문사용 ) 로인한속도증가어려움 병렬처리시에도비슷한문제발생, 더욱복잡한문제들발생가능성있음.

VBA -> C/C++ 변환 Excel 의 networkdays 함수를직접구현해주어야함. ( 어려운점 : 실무경험이부족하여 1일이상소요아직도완벽하지않음 ) 배열을사용시언어의특징고려해야함 variable(i) variable[i] Option base 1 을 option base 0 로바꿔줘야함 For 문, if 문의형식을맞춰줘야함. 특히 bracket { } 에서오류많이발생특히연산자 &&,,!, == 오류주의 대소문자오류체크 (C 언어는변수명과함수명의대소문자에민감함 ) C 언어 DLL 을이용한 excel llink 도사용가능

C 언어 Single -> CUDA 병렬코딩 병렬 MC 아이디어를사용 CPU 영역과 GPU 영역을정확히구분해줘야함 하드웨어및 CUDA 자체의특징을고려해줘야함. thread 고민 memory 고민

Thread control on SPMD algorithms How do we divide job ( FOR LOOP)? ID=0 ID=1 ID=2 ID=3 ID=0 ID=1 ID=2 ID=3

Thread control on SPMD algorithms 1 Global ELS (parameters){ Tid= blockidx.x*blockdim.x + threadidx.x; Global ELS (parameters){ N=blockDim.x *threaddim; 3 Tid= blockidx.x*blockdim.x kdi + threadidx.x; for (i = 0; i < Nsim/N; i++) { N=blockDim.x *threaddim;. for (i= Tid; i < Nsim; i+= N) { }. } } } 2 1,3 method is good Global ELS (parameters){ Tid= blockidx.x*blockdim.x + threadidx.x; N=blockDim.x *threaddim; int rem = Nsim % N; i_start = Tid * (Nsim /N); i_end = i_start + (Nsim /N); if (Tid == (N-1)) i_end = N; } for (i = i_start; i < i_end; i++) {. } 3 method is recommanded

CUDA 고급메모리관리 CUDA의제한사항 global, device 함수내부에서는 Pointer 는 global 메모리영역만지정가능 global 함수는무조건 void 함수임. static 변수의선언불가 사용방법 global 함수밖에서 static 변수를미리정의해줘야함. global 에서는메모리를참조해야함. Global l memory 의포인터주소를참조 사용예 ) Main(){ device static mt[624*n]; global memory 에할당됨 device shared static mti,bmused,y1,y2,r1,r2; device static seed; MT19937 <<<32,8>>>(void) } kernel MT19937(){ Mt[block*BlockID+ 0]=seed; }

CUDA 고급메모리관리 shared pmt19937 구현시 Nvidia G80 chip 스펙 16 KB on chip shared memory : 16384 bytes per Block (1 cycle) on device global memory : 512~1.5 GB (200 cycle) Shared Memory 가상당한고가임 필요한 Static Variables 1 개의 SMT19937 처리시필요한변수들배열 : MT[624] - 19968 bytes 변수 : mti, bmused, y1,y2,r1,r2 192 bytes 20 KB 배열만으로 H/W 제공 shared memory size 보다많이필요 Shared memory(fast) 가아닌 Global memory(slow) 사용 mti,bmused, y1,y2,r1,r2 등은 shared memory 사용가능 Global memory 사용에의한 Bottleneck 발생 5 배이상속도저하

CUDA 차세대버전에서필요한 Memory Size 차세대 Nvidia H/W 에서의필요 shared memory size 1 차 21504 byte per Block 지원시고속 shared pmt19937 구현가능 shared static mt[624]; shared static mti,bmused,y1,y2,r1,r2; device static seed; 차세대 GPU 에서 Global Memory 를 DDR5 로제공하여 bandwidth 를높이는경우에도추가적인속도향상기대됨 2 차 161280 byte per Block 지원시고속 fully pmt19937 구현가능 device static mt[624*n]; shared static mti,bmused,y1,y2,r1,r2; device static seed;

Case I Algorithm for ELS Parameter 입력 Loop 병렬화 RNG(PMT19937) -- shared / global memory version Box Muller 실행 Loop 병렬화 XT simulation 실행 <- 만들어진 RNG 사용함 ELS pricing i Routine IF문을통해조기사환, 만기조건고려평균값을구함결과출력

Case I CUDA 구조 템플릿 모듈화 Main(){ Parameter & memory copy; device boxmuller(){ ELS_bodyGPU<<<A,B>>>(); } get results; device MT19937(){ Print results; } } void ymalloc() { global ELS_bodyGPU(){ } ELS_kernel(); void yhtod() { } } void ydtoh() { device ELS_singleGPU(){ } Option pricing algorithm; void ody ytstart() { } }

Case I Pseuco code for CUDA ELS Main(){ cudamalloc((void**) &MTd, 624*sizeof(float)); cudamalloc((void**) &a, 1024*1024*2*sizeof(float)); Dim3 DimGrid(); Dim3 DimBlock(); Random_GPU <<<DimGrid,DimBlock>>> (parameters); Boxmuller_GPU <<<DimGrid,DimBlock>>> (parameters); ELS <<<DimGrid,DimBlock>>> (parameters); sum( option[k] ) /N; //N is 128 } Global ELS (parameters){ Tid= blockidx.x*blockdim.x + threadidx.x; N=blockDim.x *threaddim; For( I<0, I< Nsim/N;I++){ For(j<0,j<Totalday){ For(k=0;k<monitor;k++){ Norm1=a[N*i+ blockidx.x*blockdim.x + threadidx.x]; Norm2= a[n*(i+n)+ blockidx.x*blockdim.x + threadidx.x]; Xt1(I)= Xt1+MuT*dt + SigmaT*Norm1 Xt2(I)= Xt1+MuT*dt + SigmaT*Norm2 if (Xt1(I) <DB1 and Xt2(I) <=DB2 ) down_flag=1; } if (Xt1(I) >DB1 and Xt2(I) >=DB2 ) up_flag=1; if(j=pre1){} if(j=pre2){} } option = ; sum = sum+option; option = 1/(Nsim/N)*sum; Return option[tid]; } device float Box_Muller( float a1, float a2){ r-=sqrt(-2.0f *logf(u1)); Float phi = 2*PI*u2; a1=r* cosf(phi); a2=r* sinf(phi); } device float BoxMuller_GPU(){ Return Box_Muller( a[n*i+tid], a[n*(i+1)+tid ); } device random_gpu(){ //Use static variables for each threads Algorithms for MT RNG a[k*i+tid]=y; //K=2N }

Case I 분석 Random Number Generation 이대부분 ELS pricing 의계산시간을차지 장점 CUDA 를이용한가장빠른 parallel RNG 생성기법임함수 call 에의한오버헤드발생이거의없음 단점미리 RNG 를생성하기때문에 Memory Size 의제약을받음 RNG 를 Global Memory 에생성후 Xt 생성시 Global Memory 에서불러와야하기때문에계속적인 Memory bottle neck 발생 Critical한단점조기상환의경우미리만들어놓은 RNG 를사용할필요없음조기상환형문제해결을위한방법을고민해야함 조기상환형의경우속도향상을기대하기어려움 ( 현재 ) 조기상환형상품을 Case I의알고리즘으로구축시 GPU를사용할필요가없음 조기상환일별 RNG 를재추출하는방법으로속도향상기대 ( 코딩이복잡해짐 )

Case II Algorithm for ELS Parameter 입력 Loop 병렬화 XT simulation 실행 Boxmuller, RNG(parallel SMT19937) ELS pricing Routine IF문을통해조기사환, 만기조건고려 평균값을구함 결과출력

Case II Pseuco code for CUDA ELS Main(){ cudamalloc((void**) &MTd, 624*sizeof(float)); Dim3 DimGrid(); id() Dim3 DimBlock(); ELS_body <<<DimGrid,DimBlock>>> (parameters); sum( option[k] ) /N; //N is 128 } global ELS_ body(parameters){ Tid= blockidx.x*blockdim.x + threadidx.x; N=blockDim.x *GridDim; Initialize(); ELS_ kernel(parameters); } device ELS_ kernel(parameters){ For( I<0, I< Nsim/N;I++){ For(j<0,j<Totalday){ For(k=0;k<monitor;k++){ Norm1(i)=Box_Muller(); Norm2(I)=Box_Muller(); Xt1(I)= Xt1+MuT*dt + SigmaT*Norm1 Xt2(I)= Xt1+MuT*dt + SigmaT*Norm2 if (Xt1(I) <DB1 and Xt2(I) <=DB2 ) down_flag=1; } if (Xt1(I) >DB1 and Xt2(I) >=DB2 ) up_flag=1; if(j=pre1){} if(j=pre2){} } option = ; sum = sum+option; option = 1/(Nsim/N)*sum; Return option[tid]; } device Initialize(){ Initialize DC of MT19937 } device float Box_Muller(){ U1= MyRand();U2= MyRand(); If( used =1){ return} else {return } } SPDM1 방법론사용 device float MyRand(){ Return MT19937()/4294967296.0; } device float MT19937(){ //Use static variables for each threads Algorithms for MT RNG Return y; }

Case II single 코드의재사용 Main(){ cudamalloc((void**) &MTd, 624*sizeof(float)); Dim3 DimGrid(); id() Dim3 DimBlock(); ELS_body <<<DimGrid,DimBlock>>> (parameters); sum( option[k] ) /N; //N is 128 } global ELS_ body(parameters){ Tid= blockidx.x*blockdim.x + threadidx.x; N=blockDim.x *GridDim; Initialize(); ELS_ kernel(parameters); } device ELS_ kernel(parameters){ For( I<0, I< Nsim/N;I++){ For(j<0,j<Totalday){ For(k=0;k<monitor;k++){ Norm1(i)=Box_Muller(); Norm2(I)=Box_Muller(); Xt1(I)= Xt1+MuT*dt + SigmaT*Norm1 Xt2(I)= Xt1+MuT*dt + SigmaT*Norm2 if (Xt1(I) <DB1 and Xt2(I) <=DB2 ) down_flag=1; } if (Xt1(I) >DB1 and Xt2(I) >=DB2 ) up_flag=1; if(j=pre1){} if(j=pre2){} } option = ; sum = sum+option; option = 1/(Nsim/N)*sum; Return option[tid]; } device Initialize(){ Initialize DC of MT19937 } device float Box_Muller(){ U1= MyRand();U2= MyRand(); If( used =1){ return} else {return } } Template 과모듈이용시적색은부분만코딩해주면됨 Single code와동일한구조 device float MyRand(){ Return MT19937()/4294967296.0; } device float MT19937(){ //Use static variables for each threads Algorithms for MT RNG Return y; }

Case II 분석 장점 RNG 저장에메모리를사용하지않아이론상최대주기까지 RNG 생성가능조기상환시더이상 RNG를생성안함 Single Program 알고리즘을거의수정하지않고사용할수있음 모듈화가능 단점하나의코어에서 SMT 를돌리기위해필요한메모리용량이큼 Dynamic Creation 을통해균등분할해줘야함 고려할점고난위도 thread 컨트롤이필요 ( 모듈제작시 ) (CUDA 의자동 thread 생성기능이오히려속도저하를불러올수있음 ) Kernel 수준의 SMT 코딩필요, Global 함수에서통합관리 We need static variables but cuda do not support!!!

Case II 분석 진행상황 - 현재작업진행중 ( 디버그중 ) : 현재전체코드 491 line 모듈화작업을병행하다보니코드길이가길어짐 SPMD 1 방법을이용했음 ( 모듈화용이 ) GPU 에서 single code 를실행시켰을경우 CPU 대비 18 1.8 배느림이론상하나의보드에서약 3-40배정도성능향상기대됨현재코드에서약 12배가속됨 현재코드전체를변경할예정 SPMD 2 방법을이용하고 Memory 공유시 SPMD1 에비해 4 배속도향상기대됨 이외에몇가지속도향상기법이존재대부분메모리, thread 관리기법임.

왜 128 개의 SP 를쓰는데 128 배가안나오지? 이론상 128 개의 SP 가 128 개의 SFU 를가지고있지않고 32 개의 SFU 만가짐. GPU : 500Gflops, 최고성능 CPU : 40 Gflops : 약 40배차이일반성능 CPU 5 Gflops : 약 100 배차이 일반 CPU 1core 와 GPU 전체와비교하면 100 배정도성능차이가남 GPU 의 clock speed 가 CPU 의 clock speed 보다떨어지기때문에 GPU 의 1 개의 SP 와 CPU 1 개의 Core 를비교하면 CPU core 1 개의성능이더좋음 따라서 GPU 의 1 개 core 대비 SP 의성능 0.4~0.8 * 128 = 약 40~80 배정도성능향상효과가있음. 최초출시되었을때 CPU 대비 100 배속도상향이가능했지만, 현재는 40 배정도향상시키면최적코드로생각됨 multigpu 이용시 N 배의 scailability 보장함 (MC 방법론의경우 )

결론 Tesla C870 을이용하여 2sec 안에 ELS price 계산가능? 즉, 100 배이상속도향상가능? C870 하나의보드이용시 병렬화시 overlapping, cyclic 문제가발생할수있는 LCG 를이용시 RNG 생성시 112 배빨라짐 전체프로세스에서는 80 배향상됨 ( 업무적으로쓰기에는부적합할것으로생각됨.) MT19937 이용시, 현재 12 배정도가속됨. ( 최적화안되었음, 계속적인연구중 ) 조기종료를고려할경우에도 CPU 조기종료대비약 12 배정도 ( 약간씩오차있음 ) 빠름

결론 CUDA 를이용한 MC 병렬화 (MT19937 이용시 ) 1. 현재 12 배, 좀더최적화하면 ELS pricing 속도약 20 배향상예상 - 1개의보드장착 200sec 17.00 sec ( 현재 ) - 1개의보드장착 200sec 10.00 sec ( 최적화중 ) 2. multigpu 시스템연구예정 - 4개의보드장착된 S870 1대이용 200sec 2.50 sec ( 예상 ) 80배 - 4 개의보드장착된 S870 2 대이용 200sec 1.25 sec ( 예상 ) 160 배 3. shared memory size 의제한으로고속화불가 - block 당 2.7 KB 가능하다면약 40 배속도향상 200sec 4.00 sec ( 예상 ) LCG48 이용시 1 개의보드에서 80 배성능향상보장

연구계획

향후전망 (CUDA 를이용한금융 ) 1X 90.0sec CPU 사용 최신 3GHz CPU 사용 80X 1.1sec 300X 0.3sec 총 128 SP 사용 총 512 SP 사용 C870 1 개사용 C870 4 개사용 = S870 1 대사용 CUDA적용 ( 최적화필요, MT607) multigpu (pthread, openmp) 적용차세대보드적용 500X 0.2sec 1000X 0.09 sec 1500X 006sec 0.06 총 960 SP 사용 C1060 4 개사용 = S1070 1 대사용 multigpu (MPI) 적용 총 1920 SP 사용 C1060 8 개사용 = S1070 2 대사용 MT19937 필요 : 속도감소예상됨 총 3840 SP 사용 C1060 16개사용 = S1070 4대사용 3000X 0.03 sec 총 3840 SP 사용 C1060 32개사용 = S1070 8대사용 ( 구축시 H/W 2억원정도예상됨 ) 64X 8 node CPU cluster 비용보다저렴성능 : 60배차이 현재 : 100개상품을 9000sec = 2.5시간에계산함곧실현될미래 : 100개상품을 2sec 만에계산함

Further Research II CATs system & IBM Cell Nvidia CUDA system 총 128 SP 사용 Clearspeed CATs system 총 198 PE 사용 IBM QS system 총 8 SPE 사용 보드 4 개사용 총 512 SP 사용 보드 4 개사용 총 792 PE 사용 총 16 SPE 사용 차세대보드 4 개사용 총 1920 SP 사용 12 개보드사용 총 2376 PE 사용 총 224 SPE 사용 1000 배성능향상가능 200 배성능향상가능

The End 경청해주셔서감사합니다. 연세대수학과박사과정유현곤 E-mail : yhgon@yonsei.ac.kr