errcode.c

MPI stands for the Message Passing Interface. Written by the MPI Forum (a large committee comprising

    OBJ_CONSTRUCT(&ompi_err_file, ompi_mpi_errcode_t);
    ompi_err_file.code = MPI_ERR_FILE;
    ompi_err_file.cls = MPI_ERR_FILE;
    strcpy(ompi_err_file.errstring, "MPI_ERR_FILE: invalid file");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_FILE, &ompi_err_file);

    OBJ_CONSTRUCT(&ompi_err_info_key, ompi_mpi_errcode_t);
    ompi_err_info_key.code = MPI_ERR_INFO_KEY;
    ompi_err_info_key.cls = MPI_ERR_INFO_KEY;
    strcpy(ompi_err_info_key.errstring, "MPI_ERR_INFO_KEY: invalid key argument for info object");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INFO_KEY, &ompi_err_info_key);

    OBJ_CONSTRUCT(&ompi_err_info_nokey, ompi_mpi_errcode_t);
    ompi_err_info_nokey.code = MPI_ERR_INFO_NOKEY;
    ompi_err_info_nokey.cls = MPI_ERR_INFO_NOKEY;
    strcpy(ompi_err_info_nokey.errstring, "MPI_ERR_INFO_NOKEY: unknown key for given info object");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INFO_NOKEY, &ompi_err_info_nokey);

    OBJ_CONSTRUCT(&ompi_err_info_value, ompi_mpi_errcode_t);
    ompi_err_info_value.code = MPI_ERR_INFO_VALUE;
    ompi_err_info_value.cls = MPI_ERR_INFO_VALUE;
    strcpy(ompi_err_info_value.errstring, 
           "MPI_ERR_INFO_VALUE: invalid value argument for info object");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INFO_VALUE, &ompi_err_info_value);

    OBJ_CONSTRUCT(&ompi_err_info, ompi_mpi_errcode_t);
    ompi_err_info.code = MPI_ERR_INFO;
    ompi_err_info.cls = MPI_ERR_INFO;
    strcpy(ompi_err_info.errstring, "MPI_ERR_INFO: invalid info object");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INFO, &ompi_err_info);

    OBJ_CONSTRUCT(&ompi_err_io, ompi_mpi_errcode_t);
    ompi_err_io.code = MPI_ERR_IO;
    ompi_err_io.cls = MPI_ERR_IO;
    strcpy(ompi_err_io.errstring, "MPI_ERR_IO: input/output error");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_IO, &ompi_err_io);

    OBJ_CONSTRUCT(&ompi_err_keyval, ompi_mpi_errcode_t);
    ompi_err_keyval.code = MPI_ERR_KEYVAL;
    ompi_err_keyval.cls = MPI_ERR_KEYVAL;
    strcpy(ompi_err_keyval.errstring, "MPI_ERR_KEYVAL: invalid key value");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_KEYVAL, &ompi_err_keyval);

    OBJ_CONSTRUCT(&ompi_err_locktype, ompi_mpi_errcode_t);
    ompi_err_locktype.code = MPI_ERR_LOCKTYPE;
    ompi_err_locktype.cls = MPI_ERR_LOCKTYPE;
    strcpy(ompi_err_locktype.errstring, "MPI_ERR_LOCKTYPE: invalid lock");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_LOCKTYPE, &ompi_err_locktype);

    OBJ_CONSTRUCT(&ompi_err_name, ompi_mpi_errcode_t);
    ompi_err_name.code = MPI_ERR_NAME;
    ompi_err_name.cls = MPI_ERR_NAME;
    strcpy(ompi_err_name.errstring, "MPI_ERR_NAME: invalid name argument");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NAME, &ompi_err_name);

    OBJ_CONSTRUCT(&ompi_err_no_mem, ompi_mpi_errcode_t);
    ompi_err_no_mem.code = MPI_ERR_NO_MEM;
    ompi_err_no_mem.cls = MPI_ERR_NO_MEM;
    strcpy(ompi_err_no_mem.errstring, "MPI_ERR_NO_MEM: out of memory");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NO_MEM, &ompi_err_no_mem);

    OBJ_CONSTRUCT(&ompi_err_not_same, ompi_mpi_errcode_t);
    ompi_err_not_same.code = MPI_ERR_NOT_SAME;
    ompi_err_not_same.cls = MPI_ERR_NOT_SAME;
    strcpy(ompi_err_not_same.errstring, "MPI_ERR_NOT_SAME: objects are not identical");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NOT_SAME, &ompi_err_not_same);

    OBJ_CONSTRUCT(&ompi_err_no_space, ompi_mpi_errcode_t);
    ompi_err_no_space.code = MPI_ERR_NO_SPACE;
    ompi_err_no_space.cls = MPI_ERR_NO_SPACE;
    strcpy(ompi_err_no_space.errstring, "MPI_ERR_NO_SPACE: no space left on device");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NO_SPACE, &ompi_err_no_space);

    OBJ_CONSTRUCT(&ompi_err_no_such_file, ompi_mpi_errcode_t);
    ompi_err_no_such_file.code = MPI_ERR_NO_SUCH_FILE;
    ompi_err_no_such_file.cls = MPI_ERR_NO_SUCH_FILE;
    strcpy(ompi_err_no_such_file.errstring, "MPI_ERR_NO_SUCH_FILE: no such file or directory");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NO_SUCH_FILE, &ompi_err_no_such_file);

    OBJ_CONSTRUCT(&ompi_err_port, ompi_mpi_errcode_t);
    ompi_err_port.code = MPI_ERR_PORT;
    ompi_err_port.cls = MPI_ERR_PORT;
    strcpy(ompi_err_port.errstring, "MPI_ERR_PORT: MPI_ERR_PORT: invalid port");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_PORT, &ompi_err_port);

    OBJ_CONSTRUCT(&ompi_err_quota, ompi_mpi_errcode_t);
    ompi_err_quota.code = MPI_ERR_QUOTA;
    ompi_err_quota.cls = MPI_ERR_QUOTA;
    strcpy(ompi_err_quota.errstring, "MPI_ERR_QUOTA: out of quota");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_QUOTA, &ompi_err_quota);

    OBJ_CONSTRUCT(&ompi_err_read_only, ompi_mpi_errcode_t);
    ompi_err_read_only.code = MPI_ERR_READ_ONLY;
    ompi_err_read_only.cls = MPI_ERR_READ_ONLY;
    strcpy(ompi_err_read_only.errstring, "MPI_ERR_READ_ONLY: file is read only");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_READ_ONLY, &ompi_err_read_only);

    OBJ_CONSTRUCT(&ompi_err_rma_conflict, ompi_mpi_errcode_t);
    ompi_err_rma_conflict.code = MPI_ERR_RMA_CONFLICT;
    ompi_err_rma_conflict.cls = MPI_ERR_RMA_CONFLICT;
    strcpy(ompi_err_rma_conflict.errstring, "MPI_ERR_RMA_CONFLICT: rma conflict during operation");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_RMA_CONFLICT, &ompi_err_rma_conflict);

    OBJ_CONSTRUCT(&ompi_err_rma_sync, ompi_mpi_errcode_t);
    ompi_err_rma_sync.code = MPI_ERR_RMA_SYNC;
    ompi_err_rma_sync.cls = MPI_ERR_RMA_SYNC;
    strcpy(ompi_err_rma_sync.errstring, "MPI_ERR_RMA_SYNC: error while executing rma sync");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_RMA_SYNC, &ompi_err_rma_sync);

    OBJ_CONSTRUCT(&ompi_err_service, ompi_mpi_errcode_t);
    ompi_err_service.code = MPI_ERR_SERVICE;
    ompi_err_service.cls = MPI_ERR_SERVICE;
    strcpy(ompi_err_service.errstring, "MPI_ERR_SERVICE: unknown service name");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_SERVICE, &ompi_err_service);

    OBJ_CONSTRUCT(&ompi_err_size, ompi_mpi_errcode_t);
    ompi_err_size.code = MPI_ERR_SIZE;
    ompi_err_size.cls = MPI_ERR_SIZE;
    strcpy(ompi_err_size.errstring, "MPI_ERR_SIZE: invalid size");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_SIZE, &ompi_err_size);

    OBJ_CONSTRUCT(&ompi_err_spawn, ompi_mpi_errcode_t);
    ompi_err_spawn.code = MPI_ERR_SPAWN;
    ompi_err_spawn.cls = MPI_ERR_SPAWN;
    strcpy(ompi_err_spawn.errstring, "MPI_ERR_SPAWN: could not spawn processes");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_SPAWN, &ompi_err_spawn);

    OBJ_CONSTRUCT(&ompi_err_unsupported_datarep, ompi_mpi_errcode_t);
    ompi_err_unsupported_datarep.code = MPI_ERR_UNSUPPORTED_DATAREP;
    ompi_err_unsupported_datarep.cls = MPI_ERR_UNSUPPORTED_DATAREP;
    strcpy(ompi_err_unsupported_datarep.errstring, 
           "MPI_ERR_UNSUPPORTED_DATAREP: requested data representation not supported");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_UNSUPPORTED_DATAREP, 
                              &ompi_err_unsupported_datarep);

    OBJ_CONSTRUCT(&ompi_err_unsupported_operation, ompi_mpi_errcode_t);
    ompi_err_unsupported_operation.code = MPI_ERR_UNSUPPORTED_OPERATION;
    ompi_err_unsupported_operation.cls = MPI_ERR_UNSUPPORTED_OPERATION;
    strcpy(ompi_err_unsupported_operation.errstring, 
           "MPI_ERR_UNSUPPORTED_OPERATION: requested operation not suppported");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_UNSUPPORTED_OPERATION, 
                              &ompi_err_unsupported_operation);

    OBJ_CONSTRUCT(&ompi_err_win, ompi_mpi_errcode_t);
    ompi_err_win.code = MPI_ERR_WIN;
    ompi_err_win.cls = MPI_ERR_WIN;
    strcpy(ompi_err_win.errstring, "MPI_ERR_WIN:invalid window");
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_WIN, &ompi_err_win);

    ompi_mpi_errcode_lastused=MPI_ERR_WIN;
    ompi_mpi_errcode_lastpredefined=MPI_ERR_WIN;
    return OMPI_SUCCESS;
}

int ompi_mpi_errcode_finalize(void)
{
    int i;
    ompi_mpi_errcode_t *errc;
    
    for (i=ompi_mpi_errcode_lastpredefined+1; i<=ompi_mpi_errcode_lastused; i++) {
        /* 
         * there are some user defined error-codes, which
         * we have to free.
         */
        errc = (ompi_mpi_errcode_t *)ompi_pointer_array_get_item(&ompi_mpi_errcodes, i);
        OBJ_RELEASE (errc);
    }

    OBJ_DESTRUCT(&ompi_success);
    OBJ_DESTRUCT(&ompi_err_buffer);
    OBJ_DESTRUCT(&ompi_err_count);
    OBJ_DESTRUCT(&ompi_err_type);
    OBJ_DESTRUCT(&ompi_err_tag);
    OBJ_DESTRUCT(&ompi_err_comm);
    OBJ_DESTRUCT(&ompi_err_rank);
    OBJ_DESTRUCT(&ompi_err_request);
    OBJ_DESTRUCT(&ompi_err_root);
    OBJ_DESTRUCT(&ompi_err_group);
    OBJ_DESTRUCT(&ompi_err_op);
    OBJ_DESTRUCT(&ompi_err_topology);
    OBJ_DESTRUCT(&ompi_err_dims);
    OBJ_DESTRUCT(&ompi_err_arg);
    OBJ_DESTRUCT(&ompi_err_unknown);
    OBJ_DESTRUCT(&ompi_err_truncate);
    OBJ_DESTRUCT(&ompi_err_other);
    OBJ_DESTRUCT(&ompi_err_intern);
    OBJ_DESTRUCT(&ompi_err_in_status);
    OBJ_DESTRUCT(&ompi_err_pending);
    OBJ_DESTRUCT(&ompi_err_access);
    OBJ_DESTRUCT(&ompi_err_amode);
    OBJ_DESTRUCT(&ompi_err_assert);
    OBJ_DESTRUCT(&ompi_err_bad_file);
    OBJ_DESTRUCT(&ompi_err_base);
    OBJ_DESTRUCT(&ompi_err_conversion);
    OBJ_DESTRUCT(&ompi_err_disp);
    OBJ_DESTRUCT(&ompi_err_dup_datarep);
    OBJ_DESTRUCT(&ompi_err_file_exists);
    OBJ_DESTRUCT(&ompi_err_file_in_use);
    OBJ_DESTRUCT(&ompi_err_file);
    OBJ_DESTRUCT(&ompi_err_info_key);
    OBJ_DESTRUCT(&ompi_err_info_nokey);
    OBJ_DESTRUCT(&ompi_err_info_value);
    OBJ_DESTRUCT(&ompi_err_info);
    OBJ_DESTRUCT(&ompi_err_io);
    OBJ_DESTRUCT(&ompi_err_keyval);
    OBJ_DESTRUCT(&ompi_err_locktype);
    OBJ_DESTRUCT(&ompi_err_name);
    OBJ_DESTRUCT(&ompi_err_no_mem);
    OBJ_DESTRUCT(&ompi_err_not_same);
    OBJ_DESTRUCT(&ompi_err_no_space);
    OBJ_DESTRUCT(&ompi_err_no_such_file);
    OBJ_DESTRUCT(&ompi_err_port);
    OBJ_DESTRUCT(&ompi_err_quota);
    OBJ_DESTRUCT(&ompi_err_read_only);
    OBJ_DESTRUCT(&ompi_err_rma_conflict);
    OBJ_DESTRUCT(&ompi_err_rma_sync);
    OBJ_DESTRUCT(&ompi_err_service);
    OBJ_DESTRUCT(&ompi_err_size);
    OBJ_DESTRUCT(&ompi_err_spawn);
    OBJ_DESTRUCT(&ompi_err_unsupported_datarep);
    OBJ_DESTRUCT(&ompi_err_unsupported_operation);
    OBJ_DESTRUCT(&ompi_err_win);

    OBJ_DESTRUCT(&ompi_mpi_errcodes);
    return OMPI_SUCCESS;
}

int ompi_mpi_errcode_add(int errclass )
{
    ompi_mpi_errcode_t *newerrcode;

    newerrcode = OBJ_NEW(ompi_mpi_errcode_t);
    newerrcode->code = (ompi_mpi_errcode_lastused+1);
    newerrcode->cls = errclass;
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, newerrcode->code, newerrcode);
    
    ompi_mpi_errcode_lastused++;
    return newerrcode->code;
}

int ompi_mpi_errclass_add(void)
{
    ompi_mpi_errcode_t *newerrcode;

    newerrcode = OBJ_NEW(ompi_mpi_errcode_t);
    newerrcode->cls = ( ompi_mpi_errcode_lastused+1);
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, newerrcode->cls, newerrcode);
    
    ompi_mpi_errcode_lastused++;
    return newerrcode->cls;
}

int ompi_mpi_errnum_add_string(int errnum, char *errstring, int len)
{
    ompi_mpi_errcode_t *errcodep;

    errcodep = (ompi_mpi_errcode_t *)ompi_pointer_array_get_item(&ompi_mpi_errcodes, errnum);
    if ( NULL == errcodep ) { 
        return OMPI_ERROR;
    }

    if ( MPI_MAX_ERROR_STRING > len ) {
        len = MPI_MAX_ERROR_STRING;
    }
    
    strncpy ( errcodep->errstring, errstring, len );
    return OMPI_SUCCESS;
}

static void ompi_mpi_errcode_construct(ompi_mpi_errcode_t *errcode)
{
    errcode->code = MPI_UNDEFINED;
    errcode->cls = MPI_UNDEFINED;
    memset ( errcode->errstring, 0, MPI_MAX_ERROR_STRING);
    return;
}

static void ompi_mpi_errcode_destruct(ompi_mpi_errcode_t *errcode)
{
    ompi_pointer_array_set_item(&ompi_mpi_errcodes, errcode->code, NULL);
    return;
}