Przejdź do treści

Intel MKL

logo Intel

Wprowadzenie

Intel oneMKL (Intel oneAPI Math Kernel Library, w skrócie MKL) to złożona biblioteka firmy Intel, zawierająca wydajne funkcje obliczeniowe z wielu dziedzin. Implementuje interfejsy dobrze znanych bibliotek (BLAS/LAPACK/ScaLAPACK, FFTW), dostarcza również funkcje do generowania liczb losowych (RNG), statystyki, interpolacji (data fitting) i wiele innych. Przewidziana do obliczeń głównie na CPU, zoptymalizowana pod architekturę Intel. Posiada pewne wsparcie dla Intel GPU. Oprócz standardowego interfejsu, dostępna również dla SYCL.

Nazwa biblioteki MKL

Potocznie biblioteka jest znana jako MKL, skrót od "Math Kernel Library". Do 2020 roku pełna nazwa biblioteki to "Intel Math Kernel Library" (w skrócie Intel MKL). Wraz z wdrożeniem przez firmę Intel inicjatywy oneAPI, nazwa biblioteki została zmieniona na "Intel oneAPI Math Kernel Library" (w skrócie oneMKL). Zmiana w nazwie związana jest z wprowadzeniem nowego interfejsu opartego o SYCL.

MKL to bardzo rozbudowana biblioteka. Można na nią patrzeć jak na zestaw kilku bibliotek numerycznych o różnych zastosowaniach:

  • algebra liniowa typu BLAS/LAPACK,
    • wysoce zoptymalizowana implementacja bibliotek BLAS/LAPACK,
    • dodatkowe funkcje dla macierzy rzadkich (Sparse BLAS, Sparse Solvers),
    • implementacja biblioteki ScaLAPACK (oraz jej składowe BLACS i PBLAS);
  • szybka transformacja Fouriera (FFT),
    • oprócz własnego interfejsu posiada wrappery implementujące interfejs biblioteki FFTW;
  • matematyka wektorowa (VM, Vector Mathematics),
    • obliczanie typowych funkcji matematycznych dla każdego z elementów wektora z osobna;
  • statystyka (VS, Vector Statistics),
    • zawiera m.in. generowanie liczb losowych (tzw. RNG, Random Number Generator);
  • interpolacja funkcji (data fitting),
    • znajdowanie funkcji (sklejenia wielomianów) realizujących zadane wartości;
  • …i inne.

Biblioteka jest przewidziana przede wszystkim do obliczeń w ramach pojedynczego komputera. Posiada wsparcie dla wielowątkowości oraz akceleratorów. Do bezpośredniego użycia w modelu rozproszonym przewidziany jest ScaLAPACK oraz funkcje FFT.

Intel MKL a procesory AMD

MKL nie jest biblioteką wyłącznie dla procesorów Intel. Działa poprawnie również na procesorach firmy AMD, jednakże może nie korzystać ze wszystkich dostępnych na architekturze AMD możliwości (lub ich użycie może wymagać skorzystania z nieudokumentowanych opcji). AMD posiada swój własny zestaw bibliotek numerycznych, podobny do MKL, o nazwie AOCL (AMD Optimizing CPU Libraries).

Dostępność

MKL posiada klasyczne API dla języków C, oraz Fortran. Można używać go z różnymi kompilatorami. Dodatkowo udostępnia nowy interfejs dla modelu SYCL (czyli rozszerzonego C++), który pozwala na wykonywanie tych samych obliczeń zarówno na CPU jak i na GPU. Do skorzystania z tego ostatniego wymagany jest kompilator Intel icpx.

Aby używać MKL należy zainstalować pakiet Intel oneAPI Base Toolkit lub samodzielną dystrybucję oneMKL. Do funkcjonalności w środowisku rozproszonym potrzebny jest pakiet Intel oneAPI HPC Toolkit (zawierający Intel MPI). Więcej w informacjach o wydaniu. Dawniej MKL był dostępny w pakiecie Intel Paralel Studio XE.

Szczegóły

Aby umożliwić wsparcie dla wielu konfiguracji oprogramowania i sprzętu, MKL dostarcza wiele wariantów tej samej biblioteki. Ponieważ biblioteka dystrybuowana jest w formie skompilowanej, wybór odpowiedniego wariantu odbywa się na poziomie linkowania programu użytkownika z MKL. W tym zakresie dostępne są bardzo rozbudowane możliwości.

Dokładniej mówiąc, tak naprawdę MKL jest zbiorem wielu bibliotek. Na poziomie linkowania należy wskazać kilka z nich (poprzez podanie odpowiedniej nazwy). Oprócz tego należy podać podstawowe biblioteki, od których zależy MKL. W efekcie linkowanie z MKL może przybrać postać złożonej komendy.

anatomia linkowania z MKL

anatomia linkowania z MKL

Kluczem do zrozumienia mnogości wariantów jest struktura MKL. Opiera się ona o koncepcję kilku warstw (Layered Model Concept):

  • warstwa interfejsu (Interface Layer),
  • warstwa obsługi wątków (Threading Layer),
  • warstwa obliczeniowa (Computational Layer).

Każda z warstw odpowiada za inne zagadnienie. Są to odpowiednio obsługa różnych kompilatorów i interfejsów binarnych, modeli i bibliotek dot. wielowątkowości, oraz niskopoziomowych możliwości różnych procesorów. Dwie pierwsze warstwy dostarczają kilku możliwości wyboru, co pozwala na wiele konfiguracji.

Oprócz specyfikowania wszystkich warstw, dostępne są także łatwiejsze metody linkowania oraz narzędzie pomocnicze. Przykłady linkowania oraz szczegóły w sekcji sposoby linkowania.

Warstwa interfejsu

Warstwa ta pozwala określić sposób reprezentacji liczb całkowitych w MKL (int w C, integer w Fortran), tj. ich długość bitową. Wyróżnia się tutaj dwa interfejsy: LP64 w którym liczby te mają 32 bity, oraz ILP64 w którym mają 64 bity. W przypadku interfejsu MKL dla C, ustawienie interfejsu będzie miało wpływ na typy danych MKL MKL_INT oraz MKL_UINT.

Wybór interfejsu ma zasadnicze znaczenie w przypadku indeksacji bardzo dużych tablic. Standardowy 32-bitowy MKL_INT może przechowywać największą wartość , która może być niewystarczająca. Warianty biblioteki MKL, w zależności od interfejsu LP64 oraz ILP64, posiadają sufiks _lp64 lub _ilp64, np. libmkl_intel_lp64. Szczegółowe informacje w porównaniu ILP64 oraz LP64 dla MKL. Wspierana jest również dawna 32-bitowa architektura procesorów (IA-32), w jej przypadku należy linkować z libmkl_intel.

Niekompatybilność interfejsów

Należy pamiętać, że decydując się na konkretny interfejs (LP64 lub ILP64) musimy go stosować dla wszystkich komponentów kodu, również linkowanych zewnętrznych bibliotek. Jeśli więc wiemy, że będziemy stosować zewnętrzną bibliotekę z interfejsem LP64 nie możemy zastosować dla reszty kodu ILP64.

Warstwa interfejsu dodatkowo pozwala określić kompatybilność z kompilatorami, co ma istotne znaczenie dla interfejsu binarnego programu. Dotyczy to np. zwracania wartości funkcji w różny sposób przez kompilatory GNU oraz Intel dla języka Fortran. Kompilator GNU zwraca ją jako wartość na stosie. Natomiast kompilator Intel traktuje zwracaną wartość jako dodatkowy argument wywoływanej funkcji.

Kompatybilność biblioteki można określić poprzez nazwę jednej z bibliotek użytych do linkowania – dla Intel będzie to libmkl_intel_lp64, dla GNU (gfortran) będzie to libmkl_gf_lp64.

Warstwa obsługi wątków

Podczas linkowania z biblioteką MKL można wybrać dwie opcje: szeregową lub równoległą (tj. wielowątkową). Dla wersji równoległej należy wybrać model realizacji wielowątkowości (OpenMP lub Intel TBB). W efekcie warstwa obsługi wątków zasadniczo posiada trzy możliwości:

  • libmkl_sequential,
  • libmkl_intel_thread lub libmkl_gnu_thread, wielowątkowa w oparciu o OpenMP,
  • libmkl_tbb_thread, wielowątkowa w oparciu o Intel TBB.

Dla wersji równoległej MKL, oprócz wskazania wybranej warstwy, niezbędne jest również linkowanie programu do odpowiedniej biblioteki wykonawczej, tzw. RTL (run-time library). Przykładem RTL dla wątków są:

  • libiomp5 ─ RTL dla OpenMP, dostarczana przez kompilatory Intel, kompatybilna również z kompilatorami GNU (gcc i gfortran); wymagana przez libmkl_intel_thread;
  • libgomp ─ RTL dla OpenMP, używana przez kompilatory GNU; MKL wspiera to środowisko przez dodatkowy wariant libmkl_gnu_thread;
  • libtbb ─ RTL dla Intel TBB.

Stąd na etapie linkowania oprócz wybranej warstwy podaje się również odpowiadającą jej bibliotekę RTL. Przykładowo -lmkl_intel_thread pociąga za sobą -liomp5. Co ciekawe, wersja szeregowa libmkl_sequential wymaga linkowania z biblioteką libpthread. Więcej szczegółów w linkowanie z warstwą wielowątkowości.

Kompilatory a RTL

Biblioteka RTL dla wątków jest częścią środowiska kompilatora i nie jest dostarczana przez MKL. Różne kompilatory posiadają wsparcie dla różnych bibliotek (np. kompilatory Intel mogą korzystać wyłącznie z libomp5 lub libtbb). Linkując do MKL trzeba wskazać warstwę wątków oraz RTL zgodne z danym kompilatorem.

Należy pamiętać że program może korzystać tylko z jednej biblioteki RTL dla wątków. W związku z tym w przypadku osobnej kompilacji komponentów programu i linkowania z MKL, należy konsekwentnie wybierać tę samą RTL.

Wybór biblioteki RTL przekłada się na możliwość sterowania wątkami, poprzez wywołania odpowiednich funkcji lub zmienne środowiskowe. Przykładowe funkcjonalności to kontrola ilości wątków używanych do obliczeń oraz sposób ich przypięcia do dostępnych CPU. Więcej w sekcji wielowątkowość.

Warstwa obliczeniowa

Serce biblioteki MKL – zawiera właściwe funkcje obliczeniowe w kilku wariantach binarnych, zoptymalizowanych pod kątem różnych modeli CPU. W trakcie wykonywania programu, MKL identyfikuje architekturę CPU i dla wywołanej funkcji wybiera niskopoziomową implementację zoptymalizowaną pod kątem używanego procesora.

Dzięki temu, poszczególne funkcje MKL mogą skorzystać z cech specyficznych dla CPU na którym został uruchomiony program i zyskać na wydajności. Dla przykładu, na procesorach obsługujących AVX2 lub AVX-512, MKL może korzystać z takiej implementacji funkcji, która używa tego zestawu instrukcji.

W praktyce obsługa wielu architektur bezpośrednio przez bibliotekę MKL sprawa, że program można skompilować i zlinkować z MKL tylko jeden raz. Następnie, ten sam kod binarny programu, w zależności od tego na jakim procesorze zostanie uruchomiony, może osiągnąć różną wydajność.

Podstawową biblioteką warstwy obliczeniowej jest libmkl_core i musi ona być dodana jako jedna z bibliotek podczas linkowania z MKL. Jeśli chcemy dodatkowo użyć funkcji MKL do obliczeń rozproszonych (np. ScaLAPACK lub Cluster FFT), wymagane jest użycie dodatkowych bibliotek (odpowiednio libmkl_scalapack_lp64 oraz libmkl_cdft_core). Szczegóły w linkowaniu z warstwą obliczeniową.

Sposoby linkowania

Podstawowym sposobem linkowania jest podanie po jednej bibliotece z każdej warstwy w poleceniu dla kompilatora. Oprócz tego należy także wskazać dodatkowe biblioteki, które są wymagane przez MKL (np. RTL dla wątków).

Schemat linkowania 

icc ... -L${MKLROOT}/lib/intel64     \
        -lmkl_intel_lp64 -lmkl_sequential -lmkl_core  \
        -lpthread -lm -ldl
W powyższym poleceniu, oprócz ścieżki do MKL (-L...), wskazano:

  • libmkl_intel_lp64 ─ warstwę interfejsu (wersja LP64),
  • libmkl_sequential ─ warstwę obsługi wątków (wersja szeregowa),
  • libmkl_core ─ warstwę obliczeniową.

Biblioteki -lpthread -lm -ldl to dodatkowe zależności (np. libpthread jest wymagana przez libmkl_sequential).

Samodzielny dobór odpowiednich bibliotek, zwłaszcza w przypadku korzystania z rozproszonych obliczeń (np. ScaLAPACK), może być trudny. Aby ułatwić przygotowanie odpowiedniej komendy Intel udostępnia pomocnicze narzędzie Link Line Advisor.

Przykłady linkowania MKL – różne warianty i kompilatory

  1. Intel Classic C – wersja szeregowa z interfejsem LP64: 

    icc -o start start.c -L${MKLROOT}/lib/intel64 \ 
    -lmkl_intel_lp64 -lmkl_sequential -lmkl_core  -lpthread -lm -ldl

  2. Intel Classic Fortran – wersja równoległa (OpenMP) z interfejsem LP64: 

    ifort -o start start.f90 -L${MKLROOT}/lib/intel64 \
      -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core  -liomp5 -lpthread -lm -ldl

  3. GNU gcc – wersja równoległa (OpenMP) z użyciem libgomp (interfejs LP64): 

    gcc -o start start.c -m64 -I${MKLROOT}/include -L${MKLROOT}/lib/intel64 -Wl,--no-as-needed \
    -lmkl_intel_lp64 -lmkl_gnu_thread -lmkl_core  -lgomp -lpthread -lm -ldl

  4. GNU gfortran – wersja równoległa z użyciem libiomp5 i interfejsem ILP64: 

    gfortran -o start start.f90 -fdefault-integer-8 -m64 \
        -I${MKLROOT}/include -L${MKLROOT}/lib/intel64 -Wl,--no-as-needed \
        -lmkl_gf_ilp64 -lmkl_intel_thread -lmkl_core  -liomp5 -lpthread -lm -ldl

  5. Intel icpx – wersja równoległa oparta o Intel TBB z interfejsem ILP64 

    icpx -o start start.cpp -DMKL_ILP64 -I${MKLROOT}/include -L${MKLROOT}/lib/intel64 \
     -lmkl_intel_ilp64 -lmkl_tbb_thread -lmkl_core  -lpthread -lm -ldl

  6. Intel icx (wrapper mpiicx) – wersja równoległa ze wsparciem ScaLAPACK (dla Intel MPI) 

    mpiicx -o start start.c -L${MKLROOT}/lib/intel64 \
       -lmkl_scalapack_lp64 -lmkl_intel_lp64 -lmkl_intel_thread \
       -lmkl_core -lmkl_blacs_intelmpi_lp64  -liomp5 -lpthread -lm -ldl

Kompilatory Intel mogą korzystać z -qmkl. Jest to specjalna opcja pozwalająca na bardzo proste linkowanie z MKL. Jest dostępna zarówno dla obecnych kompilatorów icx, icpx, ifx (opartych o Clang), jak i poprzednich icc, icpc, ifort (określanych jako Intel Compiler Classic).

  • -qmkl lub -qmkl=parallel linkuje do wątkowej biblioteki MKL,
  • -qmkl=sequential linkuje do szeregowej biblioteki MKL,
  • -qmkl=cluster linkuje do szeregowej biblioteki MKL ze wsparciem dla rozpraszania obliczeń (umożliwia wykorzystanie ScaLAPACK).

Powyższe opcje wykorzystują interfejs LP64. Dla interfejsu ILP64 istnieje analogiczna opcja -qmkl-ilp64.

Linkowanie do równoległej wersji MKL z obsługą ScaLAPACK

Aby uzyskać wersję równoległą MKL ze wsparciem dla rozpraszania obliczeń (zamiast wersji szeregowej wybieranej automatycznie przez -qmkl=cluster) należy użyć: 

icc ... -qmkl=parallel -lmkl_scalapack_lp64 -lmkl_blacs_intelmpi_lp64 ...

Możliwe jest również linkowanie do pojedynczej biblioteki dynamicznej libmkl_rt, tzw. SDL (Single Dynamic Library). Dzięki jej zastosowaniu na etapie kompilacji nie trzeba specyfikować warstwy interfejsu i obsługi wątków. Ten wariant umożliwia dynamiczny wybór interfejsów na etapie uruchomienia programu. Dokonuje się tego poprzez zdefiniowanie odpowiednich zmiennych środowiskowych.

Linkowanie i uruchomienie z użyciem biblioteki SDL

Kompilacja – linkowanie wyłącznie do libmkl_rt: 

icx -o start start.c -L${MKLROOT}/lib/intel64 -lmkl_rt -Wl,--no-as-needed -lpthread -lm -ldl
Uruchomienie – wskazanie warstwy interfejsu (libmkl_intel_lp64) oraz obsługi wątków (libmkl_intel_thread):

export MKL_INTERFACE_LAYER=ILP64
export MKL_THREADING_LAYER=INTEL
./start

Wielowątkowość

Wersja równoległa MKL pozwala na kontrolę zachowania wątków. Przykładowe funkcjonalności to ustawienie ilości wątków oraz sposób ich przypięcia do dostępnych CPU. W tym celu używa się odpowiednich funkcji oraz zmiennych środowiskowych. Dostępne możliwości zależą od użytej warstwy obsługi wątków, a dokładniej od biblioteki wykonawczej dla wątków.

Uwaga – poniższy tekst odnosi się tylko do modelu wielowątkowości realizowanej przez OpenMP. Model ten jest stosowany znacznie częściej niż technologia Intel TBB.

Dla warstwy OpenMP (libmkl_intel_thread) standardowe zmienne dla OpenMP będą miały wpływ na zachowanie biblioteki MKL. Przykładowo OMP_NUM_THREADS ustawi liczbę, a OMP_PROC_BIND sposób przypięcia wątków. W przypadku środowiska Intel (libiomp5) mamy do dyspozycji także dodatkowe zmienne, np. KMP_AFFNITY. Więcej w OpenMP > Biblioteka i zmienne środowiskowe.

Biblioteka MKL (w wariancie OpenMP) posiada zestaw dodatkowych zmiennych. Najważniejsza z nich to MKL_NUM_THREADS określająca ilość wątków dostępnych dla biblioteki MKL. Zmienna ta ma priorytet nad OMP_NUM_THREADS. Wartość MKL_NUM_THREADS może być różna od OMP_NUM_THREADS, dzięki czemu kod użytkownika może być zrównoleglany inną liczbą wątków niż funkcje MKL. Domyślnie (bez ustawiania żadnej zmiennej) MKL będzie korzystał z tylu wątków ile jest dostępnych fizycznych rdzeni CPU.

Dostępna jest również bardziej szczegółowa kontrola ilości wątków w postaci MKL_DOMAIN_NUM_THREADS. Funkcje MKL podzielone są logicznie na tzw. domeny, które odpowiadają zestawom funkcji dotyczących konkretnej biblioteki numerycznej. Przykładowo domena MKL_DOMAIN_BLAS to funkcje BLAS, a MKL_DOMAIN_FFT to funkcje FFT. Zmienna MKL_DOMAIN_NUM_THREADS pozwala ustalić ilość wątków na poziomie konkretnej domeny. Dzięki temu każda domena może mieć inną konfigurację, np. 10 wątków dla funkcji BLAS, oraz brak zrównoleglania dla funkcji FFT.

Kolejne zmienne to MKL_DYNAMIC oraz MKL_NUM_STRIPES. Informacje o wszystkich zmiennych dostępne są w opisie zmiennych MKL.

Wsparcie dla GPU

Intel MKL od momentu powstania był biblioteką obliczeniową przewidzianą dla procesorów CPU (zoptymalizowaną szczególnie pod procesory firmy Intel). W ostatnich latach Intel zaczął coraz bardziej wspierać inne architektury, w tym akceleratory GPU. W szczególności firma opracowuje swoje własne rozwiązania sprzętowe tego rodzaju, które mają być stosowane w klastrach obliczeniowych (m.in. powstający superkomputer Aurora został wyposażony w karty Intel GPU). Należy jednak wskazać, że technologia Intel GPU nie jest tak dojrzała oraz stabilna jak akceleratory firmy NVIDIA, czy zyskujące popularność rozwiązania AMD.

Wyrazem rozszerzenia zakresu wspieranych rozwiązań sprzętowych, jest m.in rozszerzenie biblioteki MKL o możliwość uruchamiania niektórych funkcji na kartach Intel GPU. Można to uczynić na dwa sposoby:

  • offloading OpenMP w MKL – jest to rozwiązanie bazujące na klasycznym (dotychczasowym) interfejsie MKL; pozwala na wywołanie niektórych funkcji MKL z bloku objętego dyrektywą omp target, co spowoduje wykonanie funkcji na akceleratorze zamiast na CPU;
  • nowy interfejs (bazujący na SYCL) – jest to nowe rozwiązanie, element inicjatywy oneAPI, pozwalającej ten sam kod źródłowy uruchamiać zarówno na CPU i GPU.
Dostępność funkcji dla architektury GPU

Nie wszystkie funkcje MKL są zaimplementowane dla architektury GPU. Status wsparcia dla poszczególnych rozwiązań

Interfejs SYCL (oneAPI)

Celem inicjatywy oneAPI promowanej przez firmę Intel jest dostarczenie możliwości programowania różnych urządzeń za pomocą jednego kodu źródłowego. Takie rozwiązanie oferował już wcześniej standard SYCL i z tego względu stał się on sercem inicjatywy oneAPI. Intel zaimplementował standard SYCL (wzbogacony o własne rozszerzenia) pod nazwą Data Parallel C++. Jego obsługa jest dostępna w nowym kompilatorze icpx poprzez podanie flagi -fsycl.

W ramach inicjatywy oneAPI, MKL został przemianowany na oneMKL. W ślad za tym, biblioteka została wzbogacona o dodatkowy interfejs MKL dla SYCL. Ponieważ z założenia jest to interfejs dla C++, korzysta on z funkcjonalności tego języka (których brak w klasycznym C). Przykładem może być:

Dla przykładu, funkcja oneapi::mkl::blas::gemm zastępuje funkcje sgemm, dgemm, cgemm, zgemm. Co więcej, w nowym interfejsie MKL dodano również wsparcie dla innych typów, np. dla stosowanego w obliczeniach AI bfloat16.

Specyfikacja oneAPI a implementacja Intel oneMKL

Nazewnictwo stosowane w ramach inicjatywy oneAPI może czasem budzić pewne niejasności. Wynika to z tego, że Intel próbuje promować oneAPI jako ogólny standard, niezależny od swojej implementacji. W przypadku MKL mamy do czynienia z dwoma rozwiązaniami:

  • specyfikacja oneMKL, zawiera opis API, specyfikacja posiada swój numer (obecny to 1.2.1), pozwala na mówieniu o zgodności biblioteki ze specyfikacją;
  • Intel oneMKL, czyli omawiana tutaj konkretna biblioteka firmy Intel (przedrostek "Intel" ma wskazywać, że jest to konkretna implementacja ogólnej specyfikacji "oneMKL").

W powyższym ujęciu, Intel oneMKL to zamkniętoźródłowa implementacja specyfikacji oneMKL, przeznaczona dla procesorów CPU oraz kart GPU firmy Intel (która dodatkowo posiada stary interfejs dla języków C i Fortran).

Pomimo skupienia się Intel oneMKL na swoim sprzęcie, interfejs SYCL dla MKL może oferować pewną przenośność na inne architektury, zgodną z duchem oneAPI/SYCL. Jest tak dzięki dodatkowemu projektowi o nazwie oneMKL Interfaces. Jest to otwartoźródłowa implementacja specyfikacji oneMKL, która umożliwia wykonanie kodu oneMKL na akceleratorach różnych producentów (Intel, AMD, NVIDIA).

W praktyce jest to biblioteka pośrednicząca (wrapper), która obsługuje różne backendy. Backendy są realizowane poprzez integrację z bibliotekami innych producentów, np. cuBLAS, cuSOLVER, cuRAND, cuFFT firmy NVIDIA. W tym ujęciu Intel oneMKL jest backendem, który może wykonywać kod albo na CPU, albo na Intel GPU. Różnice zostały wytłumaczone w porównanie rozwiązań dot. oneMKL.

Informacje o wydaniu

MKL to dojrzała biblioteka, wydawana od wielu lat (początki w 2003 roku). Regularnie aktualizowana i optymalizowana pod kątem współczesnych architektur sprzętowych firmy Intel (przede wszystkich nowych możliwości CPU, a w ostatnim czasie również pod kątem Intel GPU). Jest wydawana w ramach zestawu oneAPI Base Toolkit, można ją również pobrać osobno ze strony producenta. Obecna wersja to 2023.2.0, wydana w lipcu 2023 roku (toolkit 2023.2.0). Binarne wersje bibliotek MKL mogą znajdować się w repozytoriach popularnych systemów operacyjnych z rodziny Linux. Źródła nie są publicznie dostępne. BIblioteki są dostępne dla systemów z rodziny Linux, macOS oraz Windows.

Narzędzia

  • MKL Link Line Advisor ─ narzędzie w postaci strony internetowej, pozwala na łatwe dostosowanie linkowania do bibliotek MKL dla poszczególnych kompilatorów (Intel Classic, Intel, GNU GCC, PGI czy Clang). Na stronie tej wybiera się odpowiednie opcje odpowiadające naszej architekturze, jak system operacyjny, kompilator, typ bibliotek do linkowania, interfejs OpenMP itp. a na koniec generowany jest zestaw opcji dla linkera oraz kompilatora, których należy użyć w celu zlinkowania aplikacji z MKL.

  • LAPACK Function Finding Advisor ─ wyszukiwarka funkcji LAPACK dostosowanych do naszych potrzeb. W narzędziu tym wybieramy problem obliczeniowy oraz specyfikację macierzy, których dotyczy, aby znaleźć pasujące rutyny LAPACK. Każdy wybór działa jak filtr, w rezultacie dostajemy wykaz funkcji pasujących do podanych przez nas kryteriów.

Linki

Ostatnia aktualizacja: 29 lipca 2024