Fortran 2003: учим Фортран и С дружить

в 7:14, , рубрики: c++, fortran, fortran 2003 iso_c_binding, Блог компании Intel, Программирование, метки:
Fortran 2003: учим Фортран и С дружить - 1

На языке Фортран написано огромное количество кода, отлаженного и работающего многие годы. Я не собираюсь поднимать вопрос «что лучше — Фортран или С?». У каждого языка есть свои сильные и слабые стороны. Но, учитывая большое распространение языка С, всё более популярными в определенных кругах становятся случаи «гибридных» приложений, когда часть кода пишется (скорее, уже написана) на языке Фортран, а другая – на С. Вот только у этих языков есть определенная специфика, про которую я частично уже говорил, и чтобы написанное нами приложение работало корректно, нужно учитывать много нюансов. Различия в типах данных, соглашениях о вызове (calling convention), именах (naming convention) делают задачу создания mixed language приложения далеко нетривиальной. Хорошо, что в стандарте Fortran 2003 появился целый набор средств, специально разработанный для решения задачи интероперабельности C и Фортрана. Кстати, не помню других языков, которые бы стандартизировали подобную работу — ещё один «плюсик» Фортрану за протянутую «руку дружбы».

Что же такое эта интер-опер- и так далее? Под термином «интероперабельность» имеется в виду возможность вызова в коде на языке Фортран функции С и наоборот. Кроме этого, можно использовать глобальные переменные, а так же объявлять локальные переменные, структуры данных и перечисления, имеющие соответствие в С. Основная идея — всё должно работать одинаково как в С, так и в Фортране. Стоит отметить, что под С подразумевается стандарт С99 (ISO/IEC 9899:1999). Кстати, конкретная реализация компилятора Фортран вправе выбирать, с кем из компиляторов C дружить. В случае Intel Fortan, это Microsoft Visual C++ на Windows и gcc на Linux и OS X. А что с Intel C++? Так как он совместим с Visual C++ и gcc — никаких проблем с ним нет (что и следовало ожидать).

Фортран реализует поддержку той самой интероперабельности через следующие средства:

  • Ограничения на типы данных, которые могут быть интероперабельны
  • Конструкция BIND( C )
  • Модуль ISO_C_BINDING
  • Аттрибут VALUE

Одна из основных сложностей при разработке «смешанных» приложений состоит в том, что типы в С и Фортране разные: понятия указателей, работа со строками, с указателями на функции и так далее. Да и с базовыми типами не всё так просто. Скажем, в С мы имеем типы от short int до long long int. Они могут иметь, а могу и не иметь аналогов в Фортране.
Чтобы всё это работало хорошо, в Фортране и появился модуль, отвечающий за «дружбу» этих языков — ISO_C_BINDING. Что там есть? Набор средств, который позволяет гарантировать, что типы данных в Фортране будут «правильными» для работы с кодом на С.
Например, для типа int мы можем использовать тип INTEGER(C_INT) в Фортране, а C_INT определяется в модуле ISO_C_BINDING. В случае с Intel Fortran, длина INTEGER составляет 4 байта, но в других реализациях — не факт. Использование именованной константы гарантирует портируемость.

Вот те объекты С, которые могут быть доступны для приложения на Фортране:

  • Числовые типы: целые, с плавающей точкой, комплексные
  • Логические типы (в Фортране есть типа LOGICAL)
  • Строки
  • Структуры
  • Указатели
  • Массивы
  • Глобальные переменные
  • Функции

При этом Фортрановские типы остаются старыми, но мы их модифицируем с помощью интероперабельного параметра KIND и константы из модуля. Это будет служить своего рода «связующим звеном» между типами С и Фортран. Соответствие между типами можно найти в следующей таблице:

Тип Фортрана Параметр KIND Тип С
INTEGER C_INT int
signed int
C_SHORT short int
signed short int
C_LONG long int
signed long int
C_LONG_LONG long long int
signed long long int
C_SIGNED_CHAR signed char
unsigned char
C_SIZE_T size_t
REAL C_FLOAT float
C_DOUBLE double
C_LONG_DOUBLE long double
COMPLEX C_COMPLEX _Complex
C_DOUBLE_COMPLEX double _Complex
C_LONG_DOUBLE_COMPLEX long double _Complex
LOGICAL C_BOOL _Bool
CHARACTER C_CHAR char

Хочу отметить, что в Фортране не поддерживается тип unsigned int.
Ещё одна особенность — логические типы выставляются в true/false по-разному в С и Фортране.
Если в С используется 0 для false и любое число, отличное от 0 для true, то в Фортране четные числа — false, нечетные — true.
Не забываем использовать опцию -fpscomp logicals (/fpscomp:logicals на Windows), которая меняет правила как в С.
Кстати, она подключается неявно, если использовать опцию -standard-semantics (/standard-semantics на Windows) — весьма рекомендуемая опция при работе с стандартом Fortran 2003.

Теперь давайте посмотрим, как всё работает на примере. Если мы в Фортране напишем

INTEGER(KIND=C_LONG) :: I

То использование KIND=C_LONG гарантирует нам, что у переменной I не возникнет проблем с типом при её использовании в коде C, и там она будет типа long int (в соответствии с табличкой). С встроенными типам всё просто – ищем соответствующую константу для KIND в табличке и дело в шляпе. Кстати, раз уж весь этот функционал доступен в виде модуля, то нам стоит его подключить с помощью ключевого слова USE:

USE, INTRINSIC :: ISO_C_BINDING

Таким образом нам будут доступны все константы для типов из модуля. Чтобы не засорять пространство имен, рекомендуется ограничивать область видимости только теми типами, которые мы реально собираемся использовать, например так:

USE, INTRINSIC :: ISO_C_BINDING, ONLY C_LONG

Кроме самих типов, существует так же конструкция BIND (не является частью модуля — часть стандарта Fortran 2003), который говорит компилятору языка Фортран о том, что соответствующее имя – объект С. Причем делать это можно явно и неявно. Например, у нас имеются такие глобальные переменные в С:

int a_int;
long b_long;

И мы хотим правильно использовать их в нашем коде на Фортране, например, в модуле:

MODULE TEST_BINDING
  USE ISO_C_BINDING
  ! неявный binding A_INT и a_int
  INTEGER(C_INT), BIND(C) :: A_INT
  ! явный binding B и b_long
  INTEGER(C_LONG) :: B
  BIND(C, NAME=' b_long ') :: B
END MODULE TEST_BINDING

Такая «связка» нужна для объектов. В данном примере мы сможем работать в коде на Фортране с теми самыми глобальными переменными, созданными в С. Если же у нас имеется некоторая функция, например

Cfunc(float a1, double a2);

То в качестве аргументов можно использовать такие данные, и BIND делать не нужно:

REAL(C_FLOAT) :: A1
COMPLEX(C_DOUBLE) :: A2

Одна из проблем Фортрана и С заключалась в различиях при работе со строками. Поэтому для того, чтобы в такую функцию можно было передать строку:

void copy(char in[], char out[]);

Нужно использовать KIND=C_CHAR и символ окончания строки C_NULL_CHAR (аналог в Фортране):

CHARACTER(LEN=10, KIND=C_CHAR) :: DIGIT_STRING = C_CHAR '123456789' // C_NULL_CHAR
CHARACTER(KIND=C_CHAR) :: DIGIT_ARR(10)

И наша строка из Фортрана будет здорово «дружить» с С – можно смело передавать в функцию!
Но функцию тоже нужно как-то связать с её аналогом из С. Делается это в Фортране с помощью интерфейсов:

INTERFACE
  SUBROUTINE COPY(IN, OUT), BIND(C)
    USE ISO_C_BINDING
    CHAR(KIND=C_CHAR), DIMENSION(*) :: IN, OUT
  END SUBROUTINE COPY
END INTERFACE

И вот теперь мы можем смело писать

CALL COPY(DIGIT_STRING, DIGIT_ARR)

Самое интересное – это работа с указателями. Для функции с указателями в качестве аргументов

short func(double *a; int *b; int c[10]; void *d)

можно использовать следующие переменные в Фортране:

REAL(C_DOUBLE) :: A          ! A соответствует *а, потому как в Фортране аргументы передаются по ссылке
INTEGER(C_INT) :: B, V(10)   ! B и С соответствуют *b и c[]
TYPE(C_PTR), VALUE :: D      !D соответствует *d, так как тип у указателя void*

Кроме того, что для указателей есть свой параметр KIND, имеется ещё и ряд дополнительных возможностей, например есть «нулевой» указатель C_NULL_PTR – аналог null из С. В распоряжении так же специальные функции.

C_F_POINTER ассоциирует указатель Фортрана с объектом С. Синтаксис у данной функции следующий:

CALL  C_F_POINTER( CPTR, FPTR [,SHAPE] )
TYPE(C_PTR), INTENT(IN) :: CPTR
<type_spec>, POINTER, INTENT(OUT) :: FPTR
INTEGER, INTENT(IN), OPTIONAL :: SHAPE

В качестве входного аргумента CPTR передаем указатель на объект в С, на выходе имеем Фортрановский указатель FPTR на этот объект.

C_LOC возвращает адрес объекта С или Фортран:

C_ADDRESS = C_LOC(OBJECT)

C_ASSOCIATED проверяет, выставлен наш указатель в null или нет, а так же ассоциирован ли он с объектом С.

Производные типы тоже не остались в стороне. Например, такая структура ctype

typedef struct
{
  int a, b;
  float c;
} ctype;

будет работать с типом FTYPE:

TYPE, BIND(C) :: FTYPE
  INTEGER(C_INT) :: A, B
  REAL(C_FLOAT) :: C
END TYPE FTYPE

Конечно, подробно описать все детали стандарта в рамках поста не получится, да этой цели я и не ставил, но думаю, что пролил свет на то, как всё это дело работает. Ну и заключительный примерчик, приближенный к реальности, который показывает, как модуль ISO_C_BINDING может быть использован для вызова функций как из Фортрана, так и из С.
Начнем с примера Фортрана, вызывающего С функцию:

int C_Library_Function(void* sendbuf, int sendcount, int *recvcounts);

Итак, создаем интерфейс с нужными параметрами KIND:

MODULE FTN_C_2
  INTERFACE 
   INTEGER (C_INT) FUNCTION C_LIBRARY_FUNCTION (SENDBUF, SENDCOUNT, RECVCOUNTS) BIND(C, NAME='C_LIBRARY_FUNCTION’) 
     USE, INTRINSIC :: ISO_C_BINDING  
     IMPLICIT NONE 
     TYPE (C_PTR), VALUE :: SENDBUF 
     INTEGER (C_INT), VALUE :: SENDCOUNT 
     TYPE (C_PTR), VALUE :: RECVCOUNTS 
   END FUNCTION C_LIBRARY_FUNCTION 
 END INTERFACE 
END MODULE FTN_C_2

А теперь непосредственно вызов функции:

USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_INT, C_FLOAT, C_LOC 
USE FTN_C_2 
...
REAL (C_FLOAT), TARGET :: SEND(100) 
INTEGER (C_INT) :: SENDCOUNT 
INTEGER (C_INT), ALLOCATABLE, TARGET :: RECVCOUNTS(100) 
... 
ALLOCATE( RECVCOUNTS(100) ) 
... 
CALL C_LIBRARY_FUNCTION(C_LOC(SEND), SENDCOUNT, C_LOC(RECVCOUNTS)) 
...

И никаких проблем ни с именами, ни с типами данных.
Наоборот, если у нас стоит задача вызова некоторой Фортрановской функции (весьма частая задача), то данный модуль и здесь поможет в решении проблем. Если у нас имеется функция Simulation:

SUBROUTINE SIMULATION(ALPHA, BETA, GAMMA, DELTA, ARRAYS) BIND(C) 
   USE, INTRINSIC :: ISO_C_BINDING 
   IMPLICIT NONE 
   INTEGER (C_LONG), VALUE :: ALPHA 
   REAL (C_DOUBLE), INTENT(INOUT) :: BETA 
   INTEGER (C_LONG), INTENT(OUT) :: GAMMA 
   REAL (C_DOUBLE),DIMENSION(*),INTENT(IN) :: DELTA
   TYPE, BIND(C) :: PASS 
      INTEGER (C_INT) :: LENC, LENF
      TYPE (C_PTR) :: C, F 
   END TYPE PASS 
   TYPE (PASS), INTENT(INOUT) :: ARRAYS
   REAL (C_FLOAT), ALLOCATABLE, TARGET, SAVE :: ETA(:)
   REAL (C_FLOAT), POINTER :: C_ARRAY(:) 
   ... 
   ! ассоциируем C_ARRAY с массивом, выделенным в C 
   CALL C_F_POINTER (ARRAYS%C, C_ARRAY, (/ARRAYS%LENC/) ) 
   ... 
   ! выделяем память под массив и делаем его доступным в С
   ARRAYS%LENF = 100 
   ALLOCATE (ETA(ARRAYS%LENF)) 
   ARRAYS%F = C_LOC(ETA) 
   ... 
END SUBROUTINE SIMULATION

Декларируем в С структуру:

struct pass {int lenc, lenf; float *c, *f;};

И функцию:

void simulation(long alpha, double *beta, long *gamma, double delta[], struct pass *arrays);

И можем её смело вызывать:

simulation(alpha, &beta, &gamma, delta, &arrays);

Вот и всё. Думаю, что использование этой фичи нового стандарта позволит многим разработчикам избежать большого количества проблем, а Фортран и С будут дружны как никогда.

Автор: ivorobts

Источник

Поделиться новостью

* - обязательные к заполнению поля