- CPU์์ ์คํ๋๋ ์ด๋ฏธ์ง ๋ฐ ์ ํธ ์ฒ๋ฆฌ, ๋ฒกํฐ ์ฐ์ , ์ ํ ๋์ ๋ฐ ๊ธฐ๊ณ ํ์ต์ ์ง์ํ๋ ์์ฒ ๊ฐ์ ์ ์์ค ์ํ์ ์์ธก์น๋ฅผ ์ ๊ณตํ๋ ๊ฒ์ ๋๋ค.
- ์ด๋ฅผ ํตํด ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ผ ์ ์์ต๋๋ค.
- vDSP : ํฐ ๋ฒกํฐ์ ๋ํ ์ฐ์ , ํธ๋ฆฌ์ ๋ณํ, 2 ์ฐจ ํํฐ๋ง ๋ฐ ๊ฐ๋ ฅํ ์ ํ ๋ณํ์ ํฌํจํ ๋์งํธ ์ ํธ ์ฒ๋ฆฌ ๋ฃจํด์ ์ ๊ณต
- vForce. ์ผ๊ฐ๋ฒ๊ณผ ๋ก๊ทธ ๋ฃจํด์ ํฌํจํ์ฌ ์ฐ์ ๋ฐ ์ด์ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ vForce.
- Quadrature, ํจ์์ ์์น ์ ๋ถ
- vImage๋ ๋ค์ํ ์ด๋ฏธ์ง ์ฒ๋ฆฌ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ฉฐ ํต์ฌ ๊ทธ๋ํฝ ๋ฐ ํต์ฌ ๋น๋์ค์ ์ฝ๊ฒ ํตํฉ๋ฉ๋๋ค. ๊ฐ์์ ๋ฒกํฐํ๋ฅผ ์ฌ์ฉํ์ฌ ์ฑ๋ฅ ์ด์ ์ ์ป์ต๋๋ค.
Accelerate๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ์์๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ ๋จ์ผ ๋ช ๋ น ๋ค์ค ๋ฐ์ดํฐ ๋๋ simD ๋ ์ง์คํฐ์์ ๊ณ์ฐ์ด ์ํ๋ฉ๋๋ค. ์ด๋ฌํ ๋ ์ง์คํฐ๋ ์ฌ๋ฌ ๊ฐ์ ํญ๋ชฉ์ ๋จ์ผ ๋ ์ง์คํฐ๋ก ํจํนํ์ฌ ์ฌ๋ฌ ๋ฐ์ดํฐ ํญ๋ชฉ์ ๋ํด ๋์ผํ ๋ช ๋ น์ ์ํ ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ๋จ์ผ 128 ๋นํธ ๋ ์ง์คํฐ๋ ์ค์ ๋ก 4 ๊ฐ์ 32 ๋นํธ ๋ถ๋ ์์์ ๊ฐ์ ์ ์ฅํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ๋ฒกํฐํ ๋ ๊ณฑ์ ์ฐ์ฐ์ ํ ๋ฒ์ 4 ์์ ์์๋ฅผ ๋์์ ๊ณฑํ ์ ์์ต๋๋ค. ์ฆ, ์์ ์ด ๋ ๋นจ๋ผ์ง๋ฟ๋ง ์๋๋ผ ์๋์ง ํจ์จ๋ ํฌ๊ฒ ํฅ์๋ฉ๋๋ค.
- ํธ๋ฆฌ์ ๋ณํ,
- 2 ์ฐจ ํํฐ๋ง,
- Convolution ๋ฐ ์๊ด ๊ด๊ณ ๋ถ์
- ๋ฒกํฐํ ๋ ๋์งํธ ์ ํธ ์ฒ๋ฆฌ ๊ธฐ๋ฅ
- ์์ ๋ณ ์ฐ์ ๋ฐ ํ์ ๋ณํ
๋ฐ๋ผ์ ์๋ฅผ ๋ค์ด ๋ ์ ํธ์ ์ผ๊ด์ฑ์ ๊ณ์ฐํ ํ์๊ฐ์๋ ๊ฒฝ์ฐ์๋ vDSP์ ์ผ๋ฐ ๊ณ์ฐ ๋ฃจํด์ ์ฑ ์ฑ๋ฅ์ ํฅ์์ํค๋ ์๋ฃจ์ ์ ์ ๊ณต ํ ์ ์์ต๋๋ค.
์์ : ๋ชจ๋ ๋ฐฐ์ด์ ๋ํด ๋ค์์ ์ํ + ํ๊ท
result[i] = (a[i] + b[i]) * (c[i] - d[i])
- for ๊ตฌ๋ฌธ์ผ๋ก ๋ณํ
- vDSP ํด๋์ API๋ฅผ ์ฌ์ฉ
var result = [Float](repeating: 0, count: n)
vDSP_vasbm(a, 1, b, 1, c, 1, d, 1, &result, 1, vDSP_Length(result.count))
- vDSP๋ฅผ ์ฌ์ฉํ๋ฉด 4 ๊ฐ์ ๋ฃจํ๋ณด๋ค ์ฝ 3 ๋ฐฐ ๋น ๋ฆ ๋๋ค.
- ์๋ก์ด vDSP ์ฉ Swift API๋ฅผ ์ฌ์ฉ
var result = [Float](repeating: 0, count: n)
vDSP_multiply(addition: (a, b), subtraction: (c, d), result: &result)
- ์นด์ดํธ๋ฅผ ๋ช ์์ ์ผ๋ก ์ ๋ฌํ ํ์๊ฐ ์์ผ๋ ์ข ๋ ๋ช ํํ๊ณ ๊ฐ๊ฒฐํจ.
Double ๋ฐฐ์ด์ 16๋นํธ ์ธ์๊ฐ์ผ๋ก ๋ฐ์ฌ๋ฆผํฉ๋๋ค.
let result = source.map {
return UInt16($0.rounded(.towardZero))
}
Let result = vDSP.floatingPointToInteger (source, integerType: UInt16.self,
Rounding: .towardZero)
- ๋ฆฌ์์ค ํด์ ๋ฅผ ๊ฑฑ์ ํ ํ์ ์์ด ์ฌ์ฉํ ์ ์์.
- ๊ณ ์ ์ transform ํจ์๋ฅผ ์ ๊ณตํจ
- ์ค๋์ค ์์
์ ํ๋ฉด 2์ฐจ ํํฐ๋ง ์์
์ ํ ์ ์๋๋ฐ ์ด๋
biquard
๊ธฐ๋ฅ์ ์จ์ ์ ์ฃผํ์/๊ณ ์ฃผํ์๋ฅผ ์ ๊ฑฐํ ์ ์๋ต๋๋ค.
var biquad = vDSP.Biquad(coefficients: [b0, b1, b2, a1, a2, b0, b1, b2, a1, a2], channelCount: channelCount,
sectionCount: sections,
ofType: Float.self
)
- ๊ณ์๋ฅผ ์ธ์๋ก ์ ๋ฌํ๊ณ ์ฑ๋๊ณผ ์น์ ์๋ฅผ ์ง์ ํด์ฃผ๋ฉด ์๋ ํํฐ๋ง ํด์ฅผ
-
Arithmetic functions:
floor, ceil, abs, remainder โฆ
-
Exponential and logarithmic functions:
exp, log, โฆ
-
Trigonometric functions:
sin, cos, tan, โฆ
-
Hyperbolic functions:
sing, asking, โฆ
- ์ ๊ณฑ๊ทผ(sqrt)์ ๊ณ์ฐํ๋ ๋ก์ง์ ๊ธฐ์กด map ์ฌ์ฉ ๋ก์ง๋ณด๋ค ์ต๋ 10๋ฐฐ ๋น ๋ฅธ ๋ฒกํฐํ๋ ํจ์๋ฅผ ์ ๊ณตํ๋ค.
let result = vForce.sqrt(a)
์ ํ ๋๋ ๋ฌดํ ๊ฐ๊ฒฉ์ ๋ํ ๋ช ํํ ์ ๋ถ ํจ์์ ๊ทผ์ฌ๊ฐ์ ์ ๊ณตํ๋ ํจ์
- ์๋ก์ด API๋ ๊ธฐ์กด ์ฝ๋์ ๋นํด ์๋นํ ๋จ์ํด์ง๊ณ ๊ทธ ์๋ ์ค์์
- ํตํฉ ํจ์๋ฅผ C ํจ์ ํฌ์ธํฐ๊ฐ ์๋๋ผ ํด๋ก์ ๋ฅผ ์ฌ์ฉํ ์ ์์.
Core Graphic, Core Video, Alpha blending, Format conversions, Histogram operation, Geometry, Morphology ๋ฅผ ์ํ api ์ ๊ณต
- Throwable initializer๋ฅผ ์ฌ์ฉํจ.
Any to any
: Core Video์ Core Graphic ๊ฐ ๋ณํํ ์ ์๋๋ก API๋ฅผ ์ ๊ณต- ๋น๋์ค ํฝ์ ๋ฒํผ๋ฅผ ์ด๋ฏธ์ง๋ก ์์ฝ๊ฒ ์ ํํ ์ ์๋ API ์ ๊ณต
Accelerate ํ๋ ์ ์ํฌ๊ฐ ๋์ผํ ํ๋ซํผ์์ Eigen๋ณด๋ค ๊ฑฐ์ 2.5 ๋ฐฐ ๋น ๋ฆ ๋๋ค.
Accelerate ํ๋ ์ ์ํฌ๊ฐ ํ๋ซํผ์ ๋ง๊ฒ ์กฐ์ ๋์ด ํ๋ซํผ์ด ์ ๊ณต ํ ์์๋ ๊ธฐ๋ฅ์ ์์ ํ ํ์ฉํ ์ ์๊ธฐ ๋๋ฌธ์, ์ฑ์์ Accelerate๋ฅผ ์ฌ์ฉํ๋ฉด ์ฑ๋ฅ์ด ํฅ์๋ฉ๋๋ค. ์ด ์ฑ๋ฅ์ ์๋์ง ์๋น๋ฅผ ์ค์์ผ๋ก์จ ๋ฐฐํฐ๋ฆฌ ์๋ช ์ด ํฅ์๋๊ณ ์ฌ์ฉ์์๊ฒ ๋ ๋์ ํ๊ฒฝ์ ์ ๊ณตํฉ๋๋ค. ์์ฝํ์๋ฉด Accelerate๋ ๋น ๋ฅด๊ณ ์๋์ง ํจ์จ์ ์ธ ๋๊ท๋ชจ ์ํ ๊ณ์ฐ ๋ฐ ์ด๋ฏธ์ง ๊ณ์ฐ์ ์ํํ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด์ Accelerate์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋งค์ฐ ์ฝ๊ฒ ์ฌ์ฉํ ์์๋ Swift ์นํ์ ์ธ API๋ฅผ ์ถ๊ฐํ์ฌ ์ฌ์ฉ์๊ฐ ํด๋น ์ฑ๋ฅ ๋ฐ ์๋์ง ํจ์จ์ฑ์ ํ์ฉํ ์ ์๋๋กํฉ๋๋ค.