Программируемый маршалинг вызова функции

Первая вещь большинство разработчиков рассматривает выполнение, когда они разрабатывают узел помощника, пытается сделать каждый вызов функции из сменного результата в той же функции, вызываемой в узле. С программируемым маршалингом вызова функции Ваше приложение извлекает символы из плагина, затем генерирует пользовательский код библиотеки к маршальским параметрам через границы адресного пространства (или даже от одной машины до другого).

В целом чистое число исключений и граничных включенных случаев делает программируемый вызов функции, упорядочивающий очень непрактичный, и таким образом этого нужно обычно избегать. Если плагины вызывают только C APIS, Однако этот проект может быть разумным.

Такой проект, несмотря на то, что мощный, хитер для разбираний, особенно, когда используется через границы порядка байтов, потому что этот проект требует близкого понимания каждой структуры данных, включенной, чтобы знать, должно ли поле быть подкачанным байтом. Например, свопинг различного уровня BSD, объединяющего структуры данных в сеть, имел бы катастрофические последствия.

К счастью, эти типы данных являются безусловно исключением, а не правилом, и могут обычно игнорироваться. Однако распространенное использование сокрытия структуры (например, использование void * указатели и непрозрачные типы), по существу делает программируемый вызов функции, упорядочивающий почти невозможный, потому что нет никакого способа программно решить, что глубинная структура части данных передала этим способом (и во многих случаях, значение может быть бессмысленным в контексте различного процесса).

Если плагин выполняет некоторый код в локальном процессе и передает получающиеся данные тесно связанным функциям в удаленном процессе, непрозрачные структуры данных являются особенно проблемой. Например, ссылки файловой системы (FSRef) не были бы целесообразны, когда передано через IPC к процессу, работающему на различной архитектуре из-за различий в порядке байтов в базовой (непрозрачной) структуре. Точно так же дескрипторы файлов (POSIX) функционируют по-другому в зависимости от приложения, и таким образом не могут быть полезно переданы через IPC.

Если плагин должен вызвать произвольный C++ или методы класса Objective C или методы экземпляра для классов вне самого плагина, становится еще более трудным удаленно выполнить вызовы функции из-за потребности поддержать синхронизацию экземпляров класса между узлом помощника и основным узлом. Так как Вы не можете перекомпилировать плагин, замена переменных с методами доступа невозможна. Это означает, что каждая функция, потенциально управляющая состоянием, должна скопировать все состояние от понятия основного узла экземпляра класса. Далее, существует все еще некоторая возможность, что узел мог обновить общедоступные элементы класса без Вашего ведома, приведя к потенциально существенным изменениям в Вашем хост-приложении.

Наконец, этот метод не будет работать прозрачно, если плагин вызовет какие-либо функции, включающие порты Маха, потому что права порта не совместно используются двумя процессами, если они явно не передаются от одного процесса до другой или наследованы от родителя. Точно так же Вы не должны пытаться упорядочить системные вызовы таким образом, потому что свопинг байта на более низких уровнях операционной системы может быть особенно сложным.

Ограниченный маршалинг вызова функции

Ограниченный маршалинг вызова функции является намного более реалистическим подходом, чем полностью программируемый маршалинг. Во-первых, идентифицируйте ряд (обычно C) подпрограммы, перезванивающие в хост-приложение. Затем замените тех в узле помощника с библиотеками, вызывающими через границы адресного пространства.

Поскольку объем поддерживаемого API ограничивается, это намного более практично для Вас для поддержки их посредством маршалинга вызова функции, потому что Вы можете подпрограммы ручного кода для каждой функции или класса, который Вы намереваетесь вызвать через границу адресного пространства вместо того, чтобы полагаться на программно сгенерированные функции и классы.

Как с программируемым маршалингом вызова функции, необходимо быть особенно осторожными при работе с указателями. Если параметры указателя имеют известный тип и размер, относительно просто работать с ними. Однако можно встретиться с проблемами, если Вы не знаете размер ссылочного объекта и если Вы должны к байту подкачать или иначе управлять содержанием указателя во время граничного пересечения.

C++ и классы Objective C немного более тверды. Вы не можете просто передать указатели на классы, потому что они не будут допустимы с другой стороны канала передачи. Однако, если число классов ограничивается, можно эмулировать указатели класса при помощи тупиковых классов в узле помощника, содержащих дополнительную задействованную переменную, хранящую адрес реального экземпляра класса на стороне узла.

Точно так же необходимо эмулировать любые указатели обратного вызова, переданные как параметры, потому что указатель обратного вызова бессмыслен в контексте основного хост-приложения. Можно эмулировать эти указатели или посредством передачи сообщений в обратном направлении или через RPC от основного узла в узел помощника.

При использовании ограниченного маршалинга вызова функции узел помощника может быть очень компактным и абсолютно прозрачным. Однако Ваши тупиковые библиотеки должны содержать каждую функцию, которую Вы намереваетесь переопределить. Если Вы не контролируете API сам, для большого сменного APIs этот подход может быть пугающим, особенно.

Удаленный хостинг

Удаленный хостинг строго рекомендуется для большинства реализаций хостов помощника, потому что относительно просто реализовать надежно. С удаленным хостингом, вместо того, чтобы полагаться на знание сменной архитектуры, Вы полагаетесь на свое знание самого сменного узла. Поскольку Вы управляете рассматриваемым кодом, Вы будете знать о любых изменениях в API. Кроме того, потому что интерфейс между узлом и его встроенным механизмом редко включает указатели обратного вызова, можно использовать более простой механизм связи.

С удаленным хостингом Вы создаете упрощенную версию своего приложения, не выводящего на экран пользовательского интерфейса самого (кроме возможно зеркала строк меню с надлежащей передачей сообщений к главному приложению). Это миниатюрное приложение должно включать полный набор функциональности обработки данных. В этой модели хост-приложение передает блок данных к узлу помощника, затем полагается на узел помощника для обработки данных, как встроенный сменный механизм хост-приложения был бы.

Можно принять решение добавить флаг командной строки (использование argc и argv) к Вашему приложению и, после наблюдения того флага, вызывают отдельную подпрограмму инициализации, в которой только сконфигурирована внутренняя функциональность. Если Вы делаете, Ваш узел помощника может просто быть другим рабочим экземпляром Вашего двоичного файла главного приложения.

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

• Изменения состояния к сменному уровню хост-приложения должны быть отражены в узле помощника.

• В узле помощника, каждый раз, когда плагин вызывает обратный вызов, изменяющий информацию состояния, хранившую в узле помощника, Ваше приложение должно уведомить основной узел так, чтобы эти два остались в синхронизации.

• Дополнительный код должен быть добавлен для обработки передачи любых данных, на которые будет воздействовать плагин.

Эта синхронизация состояния может быть достигнута посредством относительно прямого использования межпроцессного взаимодействия (обсужденный в Использовании Межпроцессного взаимодействия). Для транспорта больших данных необходимо обычно передавать данные с помощью отображения памяти. Этот метод описан в Памяти, Отображающейся для Объемного Транспорта Данных.

Вызов удаленной процедуры APIs

Существует три вызова удаленной процедуры, обычно использующиеся в OS X: распределенные объекты, Мах RPC и Sun RPC. Из них только распределенными объектами является общедоступный API, рекомендуемый для общего использования.

Клиент/сервер, Передающий APIs

OS X поддерживает несколько клиентов/серверов, передающих APIs, включая события Apple, сокеты BSD и каналы (стандартный ввод и вывод, например). Этот APIs описан в следующих разделах.

#include <stdlib.h>

comm_channel *startchild(char *path)

{

        comm_channel *channel = malloc(sizeof(*channel));

        pid_t childpid;

        int in_descriptors[2];

        int out_descriptors[2];

        /* Create a pair of file descriptors to use for communication. */

        if (pipe(in_descriptors) == -1) {

                fprintf(stderr, "pipe creation failed.\n");

                goto error_exit;

        }

        if (pipe(out_descriptors) == -1) {

                fprintf(stderr, "pipe creation failed.\n");

                goto error_exit;

        }

        /* Create a new child process. */

        if ((childpid = fork()) == -1) {

                fprintf(stderr, "fork failed.\n");

                goto error_exit;

        }

        if (childpid) {

                /* Parent process */

                channel->in_fd = in_descriptors[0];

                close(in_descriptors[1]);

                channel->out_fd = out_descriptors[1];

                close(out_descriptors[0]);

                return channel;

        } else {

                /* Child process */

                if (dup2(in_descriptors[1], STDOUT_FILENO) == -1) {

                        fprintf(stderr, "Call to dup2 failed.\n");

                        goto error_exit;

                }

                close(in_descriptors[0]);

                if (dup2(out_descriptors[0], STDIN_FILENO) == -1) {

                        fprintf(stderr, "Call to dup2 failed.\n");

                        goto error_exit;

                }

                close(out_descriptors[1]);

                execl(path, path, NULL);

                /* If we get here, something went wrong. */

                fprintf(stderr, "Exec failed.\n");

                goto error_exit;

        }

        return channel;

    error_exit:

        free(channel);

        perror("msg_send");

        return NULL;

}

Память, отображающаяся для объемного транспорта данных

Для перемещения больших количеств данных между двумя приложениями, если Вы не связываетесь по сети, необходимо обычно избегать большинства традиционных алгоритмов передачи сообщений из-за свойственного CPU наверху и включенной задержки. Вместо этого необходимо рассмотреть использование проекта общей памяти mmap.

Следующий пример показывает, как создать область общей памяти между процессом и его дочерним элементом:

#include <sys/types.h>

#include <sys/mman.h>

#include <sys/dirent.h>

#include <fcntl.h>

#include <stdlib.h>

/* Create the map file and fill it with bytes. */

char *create_shm_file(char *progname, int length)

{

    int fd, i;

    char *filename=malloc(MAXNAMLEN+1);

    char *ret;

    char byte = 0;

    sprintf(filename, "/tmp/%s-XXXXXXXX", progname);

    ret = mktemp(filename);

    fd = open(filename, O_RDWR|O_CREAT, 0600);

    for (i=0; i<length; i++) {

        write(fd, &byte, 1);

    }

    return ret;

}

/* Map the file into memory in a read-write fashion */

void *map_shm_file(char *filename, int length)

{

    int fd = open(filename, O_RDWR, 0);

    void *map;

    if (fd == -1) return NULL; /* Could not open file */

    map = mmap(NULL, length, PROT_READ|PROT_WRITE,

        MAP_FILE|MAP_SHARED, fd, 0);

    return map;

}

Используя этот пример кода, эти два приложения могут рандеву с помощью файла в качестве буфера общей памяти между ними. Пока оба приложения используют тот же файл, любые изменения, внесенные одним приложением, будут замечены другой и наоборот. Ваше приложение может тогда присвоить части этого буфера, который будет использоваться для различных задач, как если бы Вы использовали анонимную память, возвращенную вызовом к malloc.

Если Вы намереваетесь работать с областями размера страницы, необходимо также принять во внимание функции, описанные в mpool страница руководства. Если необходимо регулярно выделять и освобождать общую память, Однако в большинстве целей, необходимо записать собственное средство выделения пула.

Для получения дополнительной информации о функциях, используемых в примере выше, см. страницы справочника для mmap, open, и mktemp.

Хорошие методы работы с общей памятью для Вас для использования кольцевого буферного проекта без блокировок. В таком проекте каждая коммуникационная конечная точка читает из двух переменных, но записей только одной. Таким образом обе стороны знают, где в буфере работает другая конечная точка.

Например:

typedef struct ringbuffer {

    void *buffer;

    int buflen;

    int readpos;

    int writepos;

} *ringbuffer;

#define BYTES_TO_READ(ringbuffer) (ringbuffer->writepos - \

    ringbuffer->readpos + \

    ((ringbuffer->readpos > ringbuffer->writepos) * \

        (ringbuffer->buflen)))

/*  Use >= here because if readpos and writepos are equal,

    the buffer must be assumed to be empty.  Otherwise,

    the buffer would start out full. For this reason,

    the writepos must not be allowed to overtake the read

    position, so subtract one from the final value.

*/

#define BYTES_TO_WRITE(ringbuffer) (ringbuffer->readpos - \

    ringbuffer->writepos + \

    ((ringbuffer->writepos >= ringbuffer->readpos) * \

        ringbuffer->buflen) - 1)

Чтение кода от этого буфера знает, что может всегда читать из readpos вперед до writepos (или если writepos меньше, чем readpos, это может читать до конца буфера, затем читать из запуска буфера до writepos). После чтения, обновлений кода чтения readpos отразить расположение последнего побайтового чтения.

Подобным способом код, пишущий в этот буфер, знает, что это может безопасно записать из writepos позиция, пока это не достигает readpos, перенос конца буфера при необходимости. После записи, обновлений кода записи writepos отразить расположение последнего записанного байта.

Поскольку только один процесс будет когда-либо изменять также readpos или writepos, никакая синхронизация между двумя процессами не требуется. Отметьте, однако, что код чтения должен защитить readpos против других потоков в том процессе и кода записи должен сделать то же для writepos.