/**
* Operator: Finalize
*/
ngemResult_t
ngrcOperatorFinalize(
ngrcOperator_t*op)
{
globus_result_t gResult;
ngLog_t *log;
ngemResult_t ret = NGEM_SUCCESS;
NGEM_FNAME(ngrcOperatorFinalize);
log = ngemLogGetDefault();
NGEM_ASSERT(op != NULL);
op->ngo_handle = NULL;
op->ngo_canceled = false;
gResult = globus_mutex_destroy(&op->ngo_mutex);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_mutex_destroy", gResult);
ret = NGEM_FAILED;
}
gResult = globus_cond_destroy(&op->ngo_cond);
if (gResult != GLOBUS_SUCCESS) {
ngcpLogGlobusError(log, NGRC_LOGCAT_GT, fName,
"globus_cond_destroy", gResult);
ret = NGEM_FAILED;
}
return ret;
}
void
test_monitor_destroy(
test_monitor_t * monitor)
{
globus_cond_destroy(&monitor->cond);
globus_mutex_destroy(&monitor->mutex);
}
static
int
globus_l_seg_stdout_deactivate(void)
{
globus_mutex_lock(&globus_l_seg_mutex);
globus_l_seg_shutdown = 1;
if (globus_l_seg_write_registered)
{
while (globus_l_seg_shutdown == 1)
{
globus_cond_wait(&globus_l_seg_mutex, &globus_l_seg_cond);
}
}
globus_fifo_destroy(&globus_l_seg_buffers);
globus_mutex_unlock(&globus_l_seg_mutex);
globus_xio_close(globus_l_seg_output_handle, NULL);
globus_xio_close(globus_l_seg_input_handle, NULL);
globus_mutex_destroy(&globus_l_seg_mutex);
globus_cond_destroy(&globus_l_seg_cond);
globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_module_deactivate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
globus_module_deactivate(GLOBUS_COMMON_MODULE);
return 0;
}
/**
* @brief Destroy a recursive mutex
* @ingroup globus_mutex
*
* @details
* The globus_rmutex_destroy() function destroys a recursive mutex
* If the mutex is currently locked, behavior is undefined.
*
* @param rmutex
* Mutex to unlock
*
* @return GLOBUS_SUCCESS
*/
int
globus_rmutex_destroy(
globus_rmutex_t * rmutex)
{
globus_mutex_destroy(&rmutex->mutex);
globus_cond_destroy(&rmutex->cond);
return 0;
}
void
gridftp_destroy(gridftp_t * GridFTP)
{
GlobusGFSName(__func__);
GlobusGFSHpssDebugEnter();
if (GridFTP != NULL)
{
/* Destroy the file range lists. */
range_list_destroy(GridFTP->StreamRanges);
globus_mutex_destroy(&GridFTP->Lock);
globus_cond_destroy(&GridFTP->Cond);
globus_free(GridFTP);
}
GlobusGFSHpssDebugExit();
}
int
main()
{
gss_cred_id_t credential;
int listen_fd;
int accept_fd;
struct sockaddr_in address = {0};
globus_sockaddr_t connect_address;
globus_socklen_t connect_address_len = sizeof(connect_address);
struct thread_arg * arg = NULL;
globus_thread_t thread_handle;
int i;
int ret;
int error;
LTDL_SET_PRELOADED_SYMBOLS();
globus_thread_set_model(THREAD_MODEL);
globus_module_activate(GLOBUS_COMMON_MODULE);
globus_module_activate(GLOBUS_GSI_GSSAPI_MODULE);
printf("1..%d\n", NUM_CLIENTS);
/* initialize global mutex */
globus_mutex_init(&mutex, NULL);
/* and the condition variable */
globus_cond_init(&done, NULL);
/* setup listener */
address.sin_family = AF_INET;
address.sin_port = 0;
address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (listen_fd == 0)
{
perror("socket");
exit(EXIT_FAILURE);
}
ret = bind(listen_fd, (struct sockaddr *) &address, sizeof(struct sockaddr_in));
if (ret != 0)
{
perror("bind");
exit(EXIT_FAILURE);
}
ret = getsockname(listen_fd, (struct sockaddr *) &connect_address, &connect_address_len);
if (ret != 0)
{
perror("getsockname");
exit(EXIT_FAILURE);
}
ret = listen(listen_fd, -1);
if (ret != 0)
{
perror("listen");
exit(EXIT_FAILURE);
}
/* acquire credentials */
credential = globus_gsi_gssapi_test_acquire_credential();
if(credential == GSS_C_NO_CREDENTIAL)
{
fprintf(stderr,"Unable to aquire credential\n");
exit(-1);
}
/* start the clients here */
for(i=0;i<NUM_CLIENTS;i++)
{
arg = malloc(sizeof(struct thread_arg));
arg->address = &connect_address;
arg->len = connect_address_len;
arg->credential = credential;
globus_mutex_lock(&mutex);
{
client_thread_count++;
}
globus_mutex_unlock(&mutex);
globus_thread_create(&thread_handle,NULL,client_func,(void *) arg);
}
/* accept connections */
globus_mutex_lock(&mutex);
while (client_thread_count > 0)
{
while (pending_connects > 0)
{
accept_fd = accept(listen_fd,NULL,0);
if(accept_fd < 0)
{
perror("accept");
abort();
}
arg = malloc(sizeof(struct thread_arg));
arg->fd = accept_fd;
arg->credential = credential;
server_thread_count++;
pending_connects--;
globus_thread_create(&thread_handle,NULL,server_func,(void *) arg);
}
globus_cond_wait(&done, &mutex);
}
/* wait for last thread to terminate */
while (server_thread_count > 0)
{
globus_cond_wait(&done, &mutex);
}
globus_mutex_unlock(&mutex);
/* destroy global mutex */
globus_mutex_destroy(&mutex);
/* and the condition variable */
globus_cond_destroy(&done);
/* close the listener */
close(listen_fd);
/* release credentials */
globus_gsi_gssapi_test_release_credential(&credential);
globus_module_deactivate_all();
exit(client_failed);
}
int main(
int argc,
char * argv[])
{
int rc;
char * server_callback_contact;
globus_byte_t * msg;
globus_size_t msgsize;
monitor_t monitor;
rc = globus_module_activate(GLOBUS_GRAM_PROTOCOL_MODULE);
if(rc != GLOBUS_SUCCESS)
{
return rc;
}
globus_mutex_init(&monitor.mutex, GLOBUS_NULL);
globus_mutex_lock(&monitor.mutex);
globus_cond_init(&monitor.cond, GLOBUS_NULL);
monitor.done = GLOBUS_FALSE;
monitor.status_request[0] = "status";
monitor.status_request[1] = NULL;
monitor.job_status[1] = GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE;
monitor.failure_code[1] = 0;
monitor.job_failure_code[1] = 0;
monitor.error = 0;
rc = globus_gram_protocol_allow_attach(
&server_callback_contact,
server_callback,
&monitor);
if(rc != GLOBUS_SUCCESS)
{
goto unlock_error;
}
rc = globus_gram_protocol_pack_status_request(
monitor.status_request[0],
&msg,
&msgsize);
if(rc != GLOBUS_SUCCESS)
{
goto disallow_error;
}
if (argc > 1 && !strcmp(argv[1], "invalid_host"))
{
globus_free(server_callback_contact);
server_callback_contact = globus_libc_strdup(
"https://bogushost.globus.org:7777/7777");
}
rc = globus_gram_protocol_post(server_callback_contact,
GLOBUS_NULL,
GLOBUS_NULL,
msg,
msgsize,
client_callback,
&monitor);
if(rc != GLOBUS_SUCCESS)
{
goto free_msg_error;
}
while(!monitor.done)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
globus_libc_free(msg);
globus_mutex_unlock(&monitor.mutex);
globus_mutex_destroy(&monitor.mutex);
globus_cond_destroy(&monitor.cond);
if(monitor.job_status[0] != monitor.job_status[1] ||
monitor.failure_code[0] != monitor.failure_code[1] ||
monitor.job_failure_code[0] != monitor.job_failure_code[1] ||
strcmp(monitor.status_request[0], monitor.status_request[1]) != 0)
{
fprintf(stderr, "transmission error.\n");
monitor.error++;
}
globus_libc_free(monitor.status_request[1]);
globus_gram_protocol_callback_disallow(server_callback_contact);
globus_module_deactivate(GLOBUS_GRAM_PROTOCOL_MODULE);
return monitor.error;
free_msg_error:
globus_libc_free(msg);
disallow_error:
globus_gram_protocol_callback_disallow(server_callback_contact);
unlock_error:
globus_mutex_unlock(&monitor.mutex);
globus_mutex_destroy(&monitor.mutex);
globus_cond_destroy(&monitor.cond);
globus_module_deactivate(GLOBUS_GRAM_PROTOCOL_MODULE);
return rc;
}
int
main(
int argc,
char ** argv)
{
globus_xio_stack_t stack;
globus_xio_stack_t mode_e_stack;
globus_xio_handle_t xio_handle;
globus_xio_server_t server;
globus_xio_attr_t attr = NULL;
char * cs = NULL;
globus_result_t res;
int ctr;
int num_streams = 1;
globus_bool_t be_server = GLOBUS_FALSE;
int rc;
char filename[FILE_NAME_LEN];
FILE * fp;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
res = globus_xio_driver_load("mode_e", &mode_e_driver);
test_res(res);
res = globus_xio_driver_load("ordering", &ordering_driver);
test_res(res);
res = globus_xio_stack_init(&stack, NULL);
test_res(res);
res = globus_xio_stack_push_driver(stack, mode_e_driver);
test_res(res);
res = globus_xio_stack_push_driver(stack, ordering_driver);
test_res(res);
res = globus_xio_driver_load("tcp", &tcp_driver);
test_res(res);
res = globus_xio_stack_init(&mode_e_stack, NULL);
test_res(res);
res = globus_xio_stack_push_driver(mode_e_stack, tcp_driver);
test_res(res);
if (argc < 4)
{
help();
exit(1);
}
test_res(globus_xio_attr_init(&attr));
test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_SET_STACK,
mode_e_stack));
for(ctr = 1; ctr < argc; ctr++)
{
if(strcmp(argv[ctr], "-h") == 0)
{
help();
return 0;
}
else if(strcmp(argv[ctr], "-c") == 0)
{
if (argc < 5)
{
help();
exit(1);
}
cs = argv[ctr + 1];
ctr++;
}
else if(strcmp(argv[ctr], "-s") == 0)
{
be_server = GLOBUS_TRUE;
}
else if(strcmp(argv[ctr], "-p") == 0)
{
if (argc < 6)
{
help();
exit(1);
}
port = atoi(argv[ctr+1]);
/* test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_APPLY_ATTR_CNTLS,
attr_cntl_cb));*/
}
else if(strcmp(argv[ctr], "-P") == 0)
{
if (argc < 6)
{
help();
exit(1);
}
num_streams = atoi(argv[ctr+1]);
test_res(globus_xio_attr_init(&attr));
test_res(globus_xio_attr_cntl(
attr,
ordering_driver,
GLOBUS_XIO_ORDERING_SET_MAX_READ_COUNT,
num_streams));
test_res(globus_xio_attr_cntl(
attr,
mode_e_driver,
GLOBUS_XIO_MODE_E_SET_NUM_STREAMS,
num_streams));
}
else if(strcmp(argv[ctr], "-f") == 0)
{
if (ctr + 1 < argc)
{
strcpy(filename, argv[ctr + 1]);
}
else
{
help();
exit(1);
}
}
}
if (!be_server && (!cs || !*cs))
{
help();
exit(1);
}
if(be_server)
{
globus_size_t size = CHUNK_SIZE + 1;
int i, nbytes;
res = globus_xio_server_create(&server, attr, stack);
test_res(res);
globus_xio_server_get_contact_string(server, &cs);
fprintf(stdout, "Contact: %s\n", cs);
res = globus_xio_server_accept(&xio_handle, server);
test_res(res);
res = globus_xio_open(xio_handle, NULL, attr);
test_res(res);
fp = fopen(filename, "w");
while(1)
{
char * buffer;
buffer = (char *) globus_malloc(size);
for (i=0; i<size; i++)
buffer[i] = '\0';
res = globus_xio_read(
xio_handle,
buffer,
size - 1,
1,
&nbytes,
NULL);
fputs(buffer, fp);
if (res != GLOBUS_SUCCESS)
break;
}
res = globus_xio_close(xio_handle, NULL);
test_res(res);
res = globus_xio_server_close(server);
test_res(res);
res = globus_xio_driver_unload(mode_e_driver);
test_res(res);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
}
else
{
globus_size_t size = CHUNK_SIZE + 1;
int nbytes;
int i,x;
res = globus_xio_handle_create(&xio_handle, stack);
test_res(res);
res = globus_xio_stack_destroy(stack);
test_res(res);
res = globus_xio_open(xio_handle, cs, attr);
test_res(res);
globus_mutex_init(&mutex, NULL);
globus_cond_init(&cond, NULL);
fp = fopen(filename, "r");
globus_mutex_lock(&mutex);
while(!feof(fp))
{
char * buffer;
buffer = (char *) globus_malloc(size);
for (i = 0; i < size; i++)
buffer[i] = '\0';
x = fread(buffer, CHUNK_SIZE, 1, fp);
nbytes = strlen(buffer);
res = globus_xio_register_write(
xio_handle,
buffer,
nbytes,
nbytes,
NULL,
write_cb,
NULL);
test_res(res);
++y;
}
fclose(fp);
/* test_res(globus_xio_data_descriptor_init(&dd, xio_handle));
test_res(globus_xio_data_descriptor_cntl(
dd,
mode_e_driver,
GLOBUS_XIO_MODE_E_SEND_EOD,
GLOBUS_TRUE));
res = globus_xio_write(
xio_handle,
buffer,
nbytes,
nbytes,
&nbytes,
NULL);
test_res(res); */
while(y)
{
globus_cond_wait(&mutex, &cond);
}
globus_mutex_unlock(&mutex);
res = globus_xio_close(xio_handle, attr);
test_res(res);
res = globus_xio_driver_unload(mode_e_driver);
test_res(res);
res = globus_xio_driver_unload(ordering_driver);
test_res(res);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == GLOBUS_SUCCESS);
globus_mutex_destroy(&mutex);
globus_cond_destroy(&cond);
}
return 0;
}
int main(int argc, char *argv[])
{
int rc = 1;
monitor_t monitor;
char * rsl;
if (argc < 4 || (!globus_l_get_mode(&monitor, argv[2]))
|| ((monitor.timeout = atoi(argv[3])) < 0))
{
globus_libc_fprintf(stderr,
"Usage: %s RM-CONTACT MODE SAVE_STATE TIMEOUT\n"
" RM-CONTACT: resource manager contact\n"
" MODE: no-commit|no-commit-end|commit|late-commit-end\n"
" TIMEOUT: two-phase timeout in seconds\n",
argv[0]);
goto error_exit;
}
rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE);
if (rc != GLOBUS_SUCCESS)
{
globus_libc_fprintf(stderr,
"failure activating GLOBUS_GRAM_CLIENT_MODULE: %s\n",
globus_gram_client_error_string(rc));
goto error_exit;
}
rsl = globus_common_create_string(format, monitor.timeout);
if (rsl == NULL)
{
globus_libc_fprintf(stderr, "failure allocating rsl string\n");
goto deactivate_exit;
}
globus_mutex_init(&monitor.mutex, NULL);
globus_cond_init(&monitor.cond, NULL);
monitor.job_contact = NULL;
monitor.callback_contact = NULL;
rc = globus_gram_client_callback_allow(
globus_l_state_callback,
&monitor,
&monitor.callback_contact);
if (rc != GLOBUS_SUCCESS || monitor.callback_contact == NULL)
{
globus_libc_fprintf(stderr,
"failure allowing callbacks\n");
rc = -1;
goto destroy_monitor_exit;
}
globus_mutex_lock(&monitor.mutex);
rc = globus_gram_client_job_request(
argv[1],
rsl,
GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL,
monitor.callback_contact,
&monitor.job_contact);
if (monitor.job_contact != NULL)
{
globus_libc_printf("%s\n", monitor.job_contact);
}
if (rc != GLOBUS_GRAM_PROTOCOL_ERROR_WAITING_FOR_COMMIT)
{
if (rc == GLOBUS_SUCCESS)
{
globus_libc_fprintf(stderr,
"job manager did not return "
"GLOBUS_GRAM_PROTOCOL_ERROR_COMMIT_TIMED_OUT\n");
rc = -1;
}
else
{
globus_libc_fprintf(stderr,
"failure submitting job request [%d]: %s\n",
rc,
globus_gram_client_error_string(rc));
}
goto disallow_exit;
}
rc = 0;
if (monitor.mode == no_commit)
{
goto disallow_exit;
}
rc = globus_gram_client_job_signal(
monitor.job_contact,
GLOBUS_GRAM_PROTOCOL_JOB_SIGNAL_COMMIT_REQUEST,
NULL,
&monitor.job_status,
&monitor.failure_code);
if (rc != GLOBUS_SUCCESS)
{
globus_libc_fprintf(stderr,
"failure sending commit signal: %s\n",
globus_gram_client_error_string(rc));
goto disallow_exit;
}
while (monitor.job_status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE &&
monitor.job_status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
if (monitor.mode == no_commit_end)
{
rc = 0;
goto disallow_exit;
}
else if (monitor.mode == late_commit_end)
{
rc = 0;
sleep(monitor.timeout + 1);
}
rc = globus_gram_client_job_signal(
monitor.job_contact,
GLOBUS_GRAM_PROTOCOL_JOB_SIGNAL_COMMIT_END,
NULL,
&monitor.job_status,
&monitor.failure_code);
if (rc != GLOBUS_SUCCESS)
{
globus_libc_fprintf(stderr,
"failure sending commit end signal: %s\n",
globus_gram_client_error_string(rc));
goto disallow_exit;
}
disallow_exit:
if (monitor.job_contact != NULL)
{
globus_gram_client_job_contact_free(monitor.job_contact);
}
globus_mutex_unlock(&monitor.mutex);
globus_gram_client_callback_disallow(monitor.callback_contact);
destroy_monitor_exit:
if (monitor.callback_contact != NULL)
{
free(monitor.callback_contact);
}
globus_mutex_destroy(&monitor.mutex);
globus_cond_destroy(&monitor.cond);
free(rsl);
deactivate_exit:
globus_module_deactivate_all();
error_exit:
return rc;
}
void ADIOI_GRIDFTP_WriteContig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
char myname[]="ADIOI_GRIDFTP_WriteContig";
int myrank, nprocs, datatype_size;
globus_size_t len,bytes_written=0;
globus_off_t goff;
globus_result_t result;
if ( fd->access_mode&ADIO_RDONLY )
{
*error_code=MPI_ERR_AMODE;
return;
}
*error_code = MPI_SUCCESS;
MPI_Comm_size(fd->comm, &nprocs);
MPI_Comm_rank(fd->comm, &myrank);
MPI_Type_size(datatype, &datatype_size);
if (file_ptr_type != ADIO_EXPLICIT_OFFSET)
{
offset = fd->fp_ind;
}
/* Do the gridftp I/O transfer */
goff = (globus_off_t)offset;
len = ((globus_size_t)datatype_size)*((globus_size_t)count);
globus_mutex_init(&writecontig_ctl_lock, GLOBUS_NULL);
globus_cond_init(&writecontig_ctl_cond, GLOBUS_NULL);
writecontig_ctl_done=GLOBUS_FALSE;
if ( (result=globus_ftp_client_partial_put(&(gridftp_fh[fd->fd_sys]),
fd->filename,
&(oattr[fd->fd_sys]),
GLOBUS_NULL,
goff,
goff+(globus_off_t)len,
writecontig_ctl_cb,
GLOBUS_NULL))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_partial_put",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(globus_error_get(result)));
return;
}
if ( (result=globus_ftp_client_register_write(&(gridftp_fh[fd->fd_sys]),
(globus_byte_t *)buf,
len,
goff,
GLOBUS_TRUE,
writecontig_data_cb,
(void *)(&bytes_written)))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_register_write",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(globus_error_get(result)));
return;
}
/* The ctl callback won't start till the data callbacks complete, so it's
safe to wait on just the ctl callback */
globus_mutex_lock(&writecontig_ctl_lock);
while ( writecontig_ctl_done!=GLOBUS_TRUE )
globus_cond_wait(&writecontig_ctl_cond,&writecontig_ctl_lock);
globus_mutex_unlock(&writecontig_ctl_lock);
globus_mutex_destroy(&writecontig_ctl_lock);
globus_cond_destroy(&writecontig_ctl_cond);
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, bytes_written);
#endif
if (file_ptr_type != ADIO_EXPLICIT_OFFSET)
{
offset = fd->fp_ind;
fd->fp_ind += bytes_written;
fd->fp_sys_posn = fd->fp_ind;
}
else {
fd->fp_sys_posn = offset + bytes_written;
}
}
void ADIOI_GRIDFTP_WriteDiscontig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
char myname[]="ADIOI_GRIDFTP_WriteDiscontig";
int myrank,nprocs;
MPI_Aint btype_size,btype_extent;
MPI_Aint ftype_size,ftype_extent;
MPI_Aint etype_size;
MPI_Aint extent;
ADIOI_Flatlist_node *flat_file;
int buf_contig,boff,i,nblks;
globus_off_t start,end,goff;
globus_size_t bytes_written;
globus_result_t result;
MPI_Comm_rank(fd->comm,&myrank);
MPI_Comm_size(fd->comm,&nprocs);
etype_size=fd->etype_size;
MPI_Type_size(fd->filetype,&ftype_size);
MPI_Type_extent(fd->filetype,&ftype_extent);
/* This is arguably unnecessary, as this routine assumes that the
buffer in memory is contiguous */
MPI_Type_size(datatype,&btype_size);
MPI_Type_extent(datatype,&btype_extent);
ADIOI_Datatype_iscontig(datatype,&buf_contig);
if ( ( btype_extent!=btype_size ) || ( ! buf_contig ) )
{
FPRINTF(stderr,"[%d/%d] %s called with discontigous memory buffer\n",
myrank,nprocs,myname);
fflush(stderr);
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(globus_error_get(result)));
return;
}
/* from here we can assume btype_extent==btype_size */
/* Flatten out fd->filetype so we know which blocks to skip */
ADIOI_Flatten_datatype(fd->filetype);
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype && flat_file->next!=NULL)
flat_file = flat_file->next;
/* Figure out how big the area to write is */
/* ASSUMPTION: ftype_size is an integer multiple of btype_size or vice versa. */
start=(globus_off_t)(offset*etype_size);
goff=start;
boff=0;
extent=0;
nblks=0;
while ( boff < (count*btype_size) )
{
int blklen;
for (i=0;i<flat_file->count;i++)
{
if ( (boff+flat_file->blocklens[i]) < (count*btype_size) )
blklen=flat_file->blocklens[i];
else
blklen=(count*btype_size)-boff;
boff+=blklen;
extent=MAX(extent,nblks*ftype_extent+flat_file->indices[i]+blklen);
if ( boff>=(count*btype_size) )
break;
}
nblks++;
}
if ( extent < count*btype_size )
{
FPRINTF(stderr,"[%d/%d] %s error in computing extent -- extent %d is smaller than total bytes requested %d!\n",
myrank,nprocs,myname,extent,count*btype_size);
fflush(stderr);
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(globus_error_get(result)));
return;
}
end=start+(globus_off_t)extent;
FPRINTF(stderr,"[%d/%d] %s writing %d bytes into extent of %d bytes starting at offset %Ld\n",
myrank,nprocs,myname,count*btype_size,extent,(long long)start);
fflush(stderr);
/* start up the globus partial write */
globus_mutex_init(&writediscontig_ctl_lock, GLOBUS_NULL);
globus_cond_init(&writediscontig_ctl_cond, GLOBUS_NULL);
writediscontig_ctl_done=GLOBUS_FALSE;
if ( (result=globus_ftp_client_partial_put(&(gridftp_fh[fd->fd_sys]),
fd->filename,
&(oattr[fd->fd_sys]),
GLOBUS_NULL,
start,
end,
writediscontig_ctl_cb,
GLOBUS_NULL))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_partial_get",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(globus_error_get(result)));
return;
}
/* Do all the actual I/Os */
boff=0;
nblks=0;
while ( boff < (count*btype_size) )
{
int i,blklen;
for (i=0;i<flat_file->count;i++)
{
if ( (boff+flat_file->blocklens[i]) < (count*btype_size) )
blklen=flat_file->blocklens[i];
else
blklen=(count*btype_size)-boff;
if ( blklen > 0 )
{
goff=start+nblks*ftype_extent+((globus_off_t)flat_file->indices[i]);
/*
FPRINTF(stderr,"[%d/%d] %s writing %d bytes from boff=%d at goff=%Ld\n",myrank,nprocs,myname,blklen,boff,goff);
*/
if ( (result=globus_ftp_client_register_write(&(gridftp_fh[fd->fd_sys]),
((globus_byte_t *)buf)+boff,
(globus_size_t)blklen,
goff,
GLOBUS_TRUE,
writediscontig_data_cb,
(void *)(&bytes_written)))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_register_write",myname,result);
*error_code=MPI_ERR_IO;
ADIOI_Error(fd,*error_code,myname);
return;
}
boff+=blklen;
if ( boff>=(count*btype_size) )
break;
}
}
nblks++;
}
/* The ctl callback won't start till the data callbacks complete, so it's
safe to wait on just the ctl callback */
globus_mutex_lock(&writediscontig_ctl_lock);
while ( writediscontig_ctl_done!=GLOBUS_TRUE )
globus_cond_wait(&writediscontig_ctl_cond,&writediscontig_ctl_lock);
globus_mutex_unlock(&writediscontig_ctl_lock);
globus_mutex_destroy(&writediscontig_ctl_lock);
globus_cond_destroy(&writediscontig_ctl_cond);
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, bytes_written);
#endif
if (file_ptr_type != ADIO_EXPLICIT_OFFSET)
{
fd->fp_ind += extent;
fd->fp_sys_posn = fd->fp_ind;
}
else {
fd->fp_sys_posn = offset + extent;
}
}
int
close_barrier2_main(
int argc,
char ** argv)
{
int rc;
globus_xio_stack_t stack;
globus_xio_handle_t handle;
globus_result_t res;
globus_abstime_t end_time;
globus_xio_attr_t attr;
globus_l_close_called = GLOBUS_FALSE;
globus_l_closed = GLOBUS_FALSE;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
res = globus_xio_attr_init(&attr);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_stack_init(&stack, NULL);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
parse_parameters(argc, argv, stack, attr);
globus_mutex_init(&globus_l_mutex, NULL);
globus_cond_init(&globus_l_cond, NULL);
res = globus_xio_handle_create(&handle, stack);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_register_open(
handle,
"whatever",
attr,
open_cb,
NULL);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
globus_mutex_lock(&globus_l_mutex);
{
while(!globus_l_closed)
{
globus_cond_wait(&globus_l_cond, &globus_l_mutex);
}
}
globus_mutex_unlock(&globus_l_mutex);
res = globus_xio_attr_destroy(attr);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
res = globus_xio_stack_destroy(stack);
test_res(GLOBUS_XIO_TEST_FAIL_NONE, res, __LINE__, __FILE__);
test_common_end();
globus_mutex_destroy(&globus_l_mutex);
globus_cond_destroy(&globus_l_cond);
rc = globus_module_deactivate(GLOBUS_XIO_MODULE);
globus_assert(rc == 0);
fprintf(stdout, "Success.\n");
return 0;
}
/* submit a job without a callback contact, register a callback
* contact, wait for job to terminate
*/
int
test1()
{
char * callback_contact;
char * job_contact;
int rc;
monitor_t monitor;
rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE);
if(rc)
{
goto out;
}
globus_mutex_init(&monitor.mutex ,GLOBUS_NULL);
globus_cond_init(&monitor.cond, GLOBUS_NULL);
monitor.state = GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING;
rc = globus_gram_client_callback_allow(gram_state_callback,
&monitor,
&callback_contact);
if(rc != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Error creating callback contact %s.\n",
globus_gram_client_error_string(rc));
goto error_exit;
}
globus_mutex_lock(&monitor.mutex);
rc = globus_gram_client_job_request(
resource_manager_contact,
"&(executable=/bin/sleep)(arguments=10)",
GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL,
GLOBUS_NULL,
&job_contact);
if(rc != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Failed submitting job request because %s.\n",
globus_gram_client_error_string(rc));
goto destroy_callback_contact;
}
rc = globus_gram_client_job_callback_register(
job_contact,
GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED|
GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE,
callback_contact,
&monitor.state,
&monitor.errorcode);
if(rc != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Error registering callback contact because %s.\n",
globus_gram_client_error_string(rc));
goto destroy_callback_contact;
}
while(monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED &&
monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
rc = monitor.errorcode;
destroy_callback_contact:
globus_gram_client_callback_disallow(callback_contact);
globus_libc_free(callback_contact);
globus_libc_free(job_contact);
globus_mutex_unlock(&monitor.mutex);
error_exit:
globus_mutex_destroy(&monitor.mutex);
globus_cond_destroy(&monitor.cond);
globus_module_deactivate(GLOBUS_GRAM_CLIENT_MODULE);
out:
return rc;
}
void *
producer(
void * nitems_arg)
{
long i;
long nitems;
prod_data_t data;
long thread_id;
nitems = (long) nitems_arg;
globus_mutex_init(&data.mutex, (globus_mutexattr_t *) GLOBUS_NULL);
globus_cond_init(&data.cond, (globus_condattr_t *) GLOBUS_NULL);
thread_id_assign();
thread_id = thread_id_get();
wait_for_all();
for (i = 0; i < nitems ; i++)
{
data.done = GLOBUS_FALSE;
globus_mutex_lock(&queue_mutex);
{
globus_fifo_enqueue(&queue, &data);
globus_cond_signal(&queue_cond);
}
globus_mutex_unlock(&queue_mutex);
globus_mutex_lock(&data.mutex);
{
while(data.done == GLOBUS_FALSE)
{
# if (DEBUG_LEVEL > 1)
{
globus_stdio_lock();
{
printf("%04ld: producer() - "
"waiting for confirmation %d\n",
thread_id,
i);
}
globus_stdio_unlock();
}
# endif
globus_cond_wait(&data.cond, &data.mutex);
}
}
globus_mutex_unlock(&data.mutex);
}
globus_cond_destroy(&data.cond);
globus_mutex_destroy(&data.mutex);
wait_for_all();
return NULL;
}
virtual ~cond()
{
globus_cond_destroy(&cond_);
}
static
int
globus_l_seg_stdout_activate(void)
{
globus_result_t result;
globus_xio_attr_t out_attr;
globus_xio_attr_t in_attr;
int rc;
globus_l_seg_output_handle = NULL;
globus_l_seg_input_handle = NULL;
globus_l_seg_file_stack = NULL;
globus_l_seg_file_driver = NULL;
globus_l_seg_timestamp = 0;
globus_l_seg_write_registered = GLOBUS_FALSE;
globus_l_seg_shutdown = 0;
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto error;
}
rc = globus_module_activate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto deactivate_common_error;
}
rc = globus_fifo_init(&globus_l_seg_buffers);
if (rc != GLOBUS_SUCCESS)
{
goto deactivate_seg_error;
}
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto destroy_fifo_error;
}
result = globus_xio_driver_load("file", &globus_l_seg_file_driver);
if (result != GLOBUS_SUCCESS)
{
goto deactivate_xio_error;
}
result = globus_xio_stack_init(&globus_l_seg_file_stack, NULL);
if (result != GLOBUS_SUCCESS)
{
goto unload_driver_error;
}
result = globus_xio_stack_push_driver(globus_l_seg_file_stack,
globus_l_seg_file_driver);
if (result != GLOBUS_SUCCESS)
{
goto destroy_stack_error;
}
result = globus_xio_attr_init(&out_attr);
if (result != GLOBUS_SUCCESS)
{
goto destroy_stack_error;
}
result = globus_xio_attr_cntl(
out_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_FLAGS,
GLOBUS_XIO_FILE_WRONLY);
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_cntl(
out_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE,
fileno(stdout));
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_init(&in_attr);
if (result != GLOBUS_SUCCESS)
{
goto destroy_out_attr_error;
}
result = globus_xio_attr_cntl(
in_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_FLAGS,
GLOBUS_XIO_FILE_RDONLY);
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_attr_cntl(
in_attr,
globus_l_seg_file_driver,
GLOBUS_XIO_FILE_SET_HANDLE,
fileno(stdin));
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_handle_create(
&globus_l_seg_output_handle,
globus_l_seg_file_stack);
if (result != GLOBUS_SUCCESS)
{
goto destroy_in_attr_error;
}
result = globus_xio_open(globus_l_seg_output_handle, "", out_attr);
if (result != GLOBUS_SUCCESS)
{
goto close_out_handle_error;
}
result = globus_xio_handle_create(
&globus_l_seg_input_handle,
globus_l_seg_file_stack);
if (result != GLOBUS_SUCCESS)
{
goto close_out_handle_error;
}
result = globus_xio_open(globus_l_seg_input_handle, "", in_attr);
if (result != GLOBUS_SUCCESS)
{
goto close_in_handle_error;
}
rc = globus_mutex_init(&globus_l_seg_mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto close_in_handle_error;
}
rc = globus_cond_init(&globus_l_seg_cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto destroy_mutex_error;
}
result = globus_xio_register_read(
globus_l_seg_input_handle,
globus_l_seg_input_buffer,
sizeof(globus_l_seg_input_buffer),
1,
NULL,
globus_l_xio_read_eof_callback,
NULL);
if (result != GLOBUS_SUCCESS)
{
goto destroy_cond_error;
}
globus_xio_attr_destroy(in_attr);
globus_xio_attr_destroy(out_attr);
return 0;
destroy_cond_error:
globus_cond_destroy(&globus_l_seg_cond);
destroy_mutex_error:
globus_mutex_destroy(&globus_l_seg_mutex);
close_in_handle_error:
globus_xio_close(globus_l_seg_input_handle, NULL);
close_out_handle_error:
globus_xio_close(globus_l_seg_output_handle, NULL);
destroy_in_attr_error:
globus_xio_attr_destroy(in_attr);
destroy_out_attr_error:
globus_xio_attr_destroy(out_attr);
destroy_stack_error:
globus_xio_stack_destroy(globus_l_seg_file_stack);
unload_driver_error:
globus_xio_driver_unload(globus_l_seg_file_driver);
deactivate_xio_error:
globus_module_deactivate(GLOBUS_XIO_MODULE);
destroy_fifo_error:
globus_fifo_destroy(&globus_l_seg_buffers);
deactivate_seg_error:
globus_module_deactivate(GLOBUS_SCHEDULER_EVENT_GENERATOR_MODULE);
deactivate_common_error:
globus_module_deactivate(GLOBUS_COMMON_MODULE);
error:
return 1;
}
int
main(int argc, char *argv[])
{
int rc;
globus_gram_client_attr_t attr;
struct monitor_t monitor;
if (argc < 3)
{
fprintf(stderr, "Usage: %s RESOURCE-MANAGER-CONTACT RSL-SPEC...\n",
argv[0]);
rc = 1;
goto out;
}
printf("Submiting job to %s with full proxy\n", argv[1]);
/*
* Always activate the GLOBUS_GRAM_CLIENT_MODULE prior to using any
* functions from the GRAM Client API or behavior is undefined.
*/
rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Error activating %s because %s (Error %d)\n",
GLOBUS_GRAM_CLIENT_MODULE->module_name,
globus_gram_client_error_string(rc),
rc);
goto out;
}
rc = globus_mutex_init(&monitor.mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Error initializing mutex %d\n", rc);
goto deactivate;
}
rc = globus_cond_init(&monitor.cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Error initializing condition variable %d\n", rc);
goto destroy_mutex;
}
monitor.done = GLOBUS_FALSE;
/* Initialize attribute so that we can set the delegation attribute */
rc = globus_gram_client_attr_init(&attr);
/* Set the proxy attribute */
rc = globus_gram_client_attr_set_delegation_mode(
attr,
GLOBUS_IO_SECURE_DELEGATION_MODE_FULL_PROXY);
/* Submit the job rsl from argv[2]
*/
globus_mutex_lock(&monitor.mutex);
/* When the job has been submitted, the example_submit_callback
* will be called, either from another thread or from a
* globus_cond_wait in a nonthreaded build
*/
rc = globus_gram_client_register_job_request(
argv[1], argv[2], 0, NULL, attr, example_submit_callback,
&monitor);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Unable to submit job %s because %s (Error %d)\n",
argv[2], globus_gram_client_error_string(rc), rc);
}
/* Wait until the example_submit_callback function has been called for
* the job submission
*/
while (!monitor.done)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
globus_cond_destroy(&monitor.cond);
destroy_mutex:
globus_mutex_destroy(&monitor.mutex);
deactivate:
/*
* Deactivating the module allows it to free memory and close network
* connections.
*/
rc = globus_module_deactivate(GLOBUS_GRAM_CLIENT_MODULE);
out:
return rc;
}
void ADIOI_GRIDFTP_ReadDiscontig(ADIO_File fd, void *buf, int count,
MPI_Datatype datatype, int file_ptr_type,
ADIO_Offset offset, ADIO_Status *status, int
*error_code)
{
char myname[]="ADIOI_GRIDFTP_ReadDiscontig";
int myrank,nprocs;
/* size and extent of buffer in memory */
MPI_Aint btype_size,btype_extent;
/* size and extent of file record layout */
MPI_Aint ftype_size,ftype_extent;
/* size of file elemental type; seeks are done in units of this */
MPI_Aint etype_size;
MPI_Aint extent;
ADIOI_Flatlist_node *flat_file;
int i,buf_contig,boff,nblks;
globus_off_t start,end,goff;
globus_size_t bytes_read;
globus_result_t result;
globus_byte_t *tmp;
if ( fd->access_mode&MPI_MODE_WRONLY )
{
*error_code=MPIR_ERR_MODE_WRONLY;
return;
}
*error_code=MPI_SUCCESS;
MPI_Comm_rank(fd->comm,&myrank);
MPI_Comm_size(fd->comm,&nprocs);
etype_size=fd->etype_size;
MPI_Type_size(fd->filetype,&ftype_size);
MPI_Type_extent(fd->filetype,&ftype_extent);
/* This is arguably unnecessary, as this routine assumes that the
buffer in memory is contiguous */
MPI_Type_size(datatype,&btype_size);
MPI_Type_extent(datatype,&btype_extent);
ADIOI_Datatype_iscontig(datatype,&buf_contig);
if ( ( btype_extent!=btype_size ) || ( ! buf_contig ) )
{
FPRINTF(stderr,"[%d/%d] %s called with discontigous memory buffer\n",
myrank,nprocs,myname);
fflush(stderr);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myname, __LINE__,
MPI_ERR_IO, "**io", 0 );
return;
}
/* from here we can assume btype_extent==btype_size */
/* Flatten out fd->filetype so we know which blocks to skip */
ADIOI_Flatten_datatype(fd->filetype);
flat_file = ADIOI_Flatlist;
while (flat_file->type != fd->filetype && flat_file->next!=NULL)
flat_file = flat_file->next;
/* Figure out how big the area to read is */
start=(globus_off_t)(offset*etype_size);
goff=start;
boff=0;
extent=0;
nblks=0;
while ( boff < (count*btype_size) )
{
int blklen=0;
for (i=0;i<flat_file->count;i++)
{
/* find the length of the next block */
if ( (boff+flat_file->blocklens[i]) < (count*btype_size) )
blklen=flat_file->blocklens[i];
else
blklen=(count*btype_size)-boff;
/* increment buffer size to be used */
boff+=blklen;
/* compute extent -- the nblks*ftype_extent bit is
there so we remember how many ftypes we've already
been through */
extent=MAX(extent,nblks*ftype_extent+flat_file->indices[i]+blklen);
if ( boff>=(count*btype_size) )
break;
}
nblks++;
}
if ( extent < count*btype_size )
{
fprintf(stderr,"[%d/%d] %s error in computing extent -- extent %d is smaller than total bytes requested %d!\n",
myrank,nprocs,myname,extent,count*btype_size);
fflush(stderr);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myanem, __LINE__,
MPI_ERR_IO, "**io", 0);
return;
}
end=start+(globus_off_t)extent;
tmp=(globus_byte_t *)malloc((size_t)extent*sizeof(globus_byte_t));
/* start up the globus partial read */
globus_mutex_init(&readdiscontig_ctl_lock, GLOBUS_NULL);
globus_cond_init(&readdiscontig_ctl_cond, GLOBUS_NULL);
readdiscontig_ctl_done=GLOBUS_FALSE;
if ( (result=globus_ftp_client_partial_get(&(gridftp_fh[fd->fd_sys]),
fd->filename,
&(oattr[fd->fd_sys]),
GLOBUS_NULL,
start,
end,
readdiscontig_ctl_cb,
GLOBUS_NULL))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_partial_get",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, myanem, __LINE__,
MPI_ERR_IO, "**io", "**io %s",
globus_object_printable_to_string(result));
return;
}
/* Do all the actual I/Os */
/* Since globus_ftp_client_register_read() is brain-dead and doesn't
let you specify an offset, we have to slurp the entire extent into
memory and then parse out the pieces we want... Sucks, doesn't it?
This should probably be done in chunks (preferably of a size
set using a file hint), but that'll have to come later.
--TB */
if ( (result=globus_ftp_client_register_read(&(gridftp_fh[fd->fd_sys]),
tmp,
(globus_size_t)extent,
readdiscontig_data_cb,
(void *)(&bytes_read)))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_register_read",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCESS, MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io",
"**io %s", globus_object_printable_to_string(result));
return;
}
/* The ctl callback won't start till the data callbacks complete, so it's
safe to wait on just the ctl callback */
globus_mutex_lock(&readdiscontig_ctl_lock);
while ( readdiscontig_ctl_done!=GLOBUS_TRUE )
globus_cond_wait(&readdiscontig_ctl_cond,&readdiscontig_ctl_lock);
globus_mutex_unlock(&readdiscontig_ctl_lock);
globus_mutex_destroy(&readdiscontig_ctl_lock);
globus_cond_destroy(&readdiscontig_ctl_cond);
boff=0;
nblks=0;
goff=0;
while ( boff < (count*btype_size) )
{
int i,blklen;
for (i=0;i<flat_file->count;i++)
{
if ( (boff+flat_file->blocklens[i]) < (count*btype_size) )
blklen=flat_file->blocklens[i];
else
blklen=(count*btype_size)-boff;
if ( blklen > 0 )
{
goff=nblks*ftype_extent+flat_file->indices[i];
memcpy((globus_byte_t *)buf+boff,tmp+goff,(size_t)blklen);
boff+=blklen;
if ( boff>=(count*btype_size) )
break;
}
}
nblks++;
}
free(tmp);
#ifdef HAVE_STATUS_SET_BYTES
MPIR_Status_set_bytes(status, datatype, bytes_read);
#endif
if (file_ptr_type != ADIO_EXPLICIT_OFFSET)
{
fd->fp_ind += extent;
fd->fp_sys_posn = fd->fp_ind;
}
else {
fd->fp_sys_posn = offset + extent;
}
}
int
globus_i_xio_win32_complete_deactivate(void)
{
globus_result_t result;
globus_l_shutdown_info_t info;
GlobusXIOName(globus_i_xio_win32_complete_deactivate);
GlobusXIOSystemDebugEnter();
if (!globus_i_am_only_thread())
{
goto skip_deactivate;
}
globus_mutex_init(&info.mutex, NULL);
globus_cond_init(&info.cond, NULL);
globus_mutex_lock(&info.mutex);
{
result = globus_callback_unregister(
globus_l_xio_win32_poll_handle,
globus_l_xio_win32_unregister_poll_cb,
&info,
0);
if(result == GLOBUS_SUCCESS)
{
/* unregister callback destroys this event object */
while(globus_l_xio_win32_poll_event != 0)
{
globus_cond_wait(&info.cond, &info.mutex);
}
}
else
{
globus_mutex_unlock(&info.mutex);
globus_l_xio_win32_unregister_poll_cb(&info);
globus_mutex_lock(&info.mutex);
}
}
globus_mutex_unlock(&info.mutex);
globus_cond_destroy(&info.cond);
globus_mutex_destroy(&info.mutex);
win32_mutex_destroy(&globus_l_xio_win32_poll_lock);
while(globus_l_xio_win32_poll_free)
{
globus_l_xio_win32_poll_entry_t * next =
globus_l_xio_win32_poll_free->next;
globus_free(globus_l_xio_win32_poll_free);
globus_l_xio_win32_poll_free = next;
}
skip_deactivate:
GlobusXIOSystemDebugExit();
return GLOBUS_SUCCESS;
}
void ADIOI_GRIDFTP_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct,
int *error_code)
{
MPI_Datatype copy_etype, copy_filetype;
int combiner, i, j, k, filetype_is_contig, err;
ADIOI_Flatlist_node *flat_file;
char myname[]="ADIOI_GRIDFTP_Fcntl";
int myrank, nprocs;
*error_code = MPI_SUCCESS;
MPI_Comm_size(fd->comm, &nprocs);
MPI_Comm_rank(fd->comm, &myrank);
switch(flag) {
case ADIO_FCNTL_GET_FSIZE:
{
globus_result_t result;
globus_off_t fsize=0;
globus_mutex_init(&fcntl_size_lock,GLOBUS_NULL);
globus_cond_init(&fcntl_size_cond,GLOBUS_NULL);
fcntl_size_done=GLOBUS_FALSE;
if ( (result=globus_ftp_client_size(&(gridftp_fh[fd->fd_sys]),
fd->filename,
&(oattr[fd->fd_sys]),
&(fsize),
fcntl_size_cb,
GLOBUS_NULL))!=GLOBUS_SUCCESS )
{
globus_err_handler("globus_ftp_client_size",myname,result);
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__, MPI_ERR_IO,
"**io", "**io %s",
globus_object_printable_to_string(globus_error_get(result)));
return;
}
globus_mutex_lock(&fcntl_size_lock);
while ( fcntl_size_done!=GLOBUS_TRUE )
globus_cond_wait(&fcntl_size_lock,&fcntl_size_cond);
globus_mutex_unlock(&fcntl_size_lock);
globus_mutex_destroy(&fcntl_size_lock);
globus_cond_destroy(&fcntl_size_cond);
fcntl_struct->fsize=fsize;
}
*error_code = MPI_SUCCESS;
break;
case ADIO_FCNTL_SET_DISKSPACE:
ADIOI_GEN_Prealloc(fd, fcntl_struct->diskspace, error_code);
break;
case ADIO_FCNTL_SET_ATOMICITY:
default:
*error_code = MPIO_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE,
myname, __LINE__,
MPI_ERR_ARG,
"**flag", "**flag %d", flag);
}
}
int
main(
int argc,
char * argv[])
{
int i;
int nitems;
long thread_id;
globus_thread_t thread;
globus_thread_set_model("pthread");
globus_module_activate(GLOBUS_COMMON_MODULE);
if (argc != 4)
{
globus_stdio_lock();
{
printf("\nusage: globus_thread_test "
"nproducers nconsumers nitems\n\n");
}
globus_stdio_unlock();
exit(1);
}
nproducers = atoi(argv[1]);
nconsumers = atoi(argv[2]);
nitems = atoi(argv[3]);
/*
* Initialize queue and queue concurrency control structures
*/
globus_fifo_init(&queue);
globus_mutex_init(&queue_mutex, (globus_mutexattr_t *) GLOBUS_NULL);
globus_cond_init(&queue_cond, (globus_condattr_t *) GLOBUS_NULL);
/*
* Initialize shared (common) concurrency control structures
*/
globus_mutex_init(&common_mutex, (globus_mutexattr_t *) GLOBUS_NULL);
globus_cond_init(&common_cond, (globus_condattr_t *) GLOBUS_NULL);
/*
* Assign a thread id to the main thread so that it's output is uniquely
* tagged. Note: we do not use the return value of globus_thread_self()
* since it could be a pointer or a structure, the latter which is
* extremely hard to print without knowing the implementation details.
*/
thread_id_assign();
thread_id = thread_id_get();
/*
* Start producer and consumer threads
*/
globus_stdio_lock();
{
printf("%04ld: main() - starting %d producer and %d consumer threads\n",
thread_id,
nproducers,
nconsumers);
}
globus_stdio_unlock();
for (i = 0 ; i < nproducers ; i ++)
{
int rc;
int nitems_per_thread;
nitems_per_thread = nitems / nproducers +
((i < nitems % nproducers) ? 1 : 0);
rc =
globus_thread_create(
&thread,
NULL,
producer,
(void *) nitems_per_thread);
if (rc != 0)
{
globus_stdio_lock();
{
printf("%04ld: main() - ERROR: "
"unable to create producer thread %d\n",
thread_id,
i);
exit(1);
}
globus_stdio_unlock();
}
}
for (i = 0 ; i < nconsumers ; i ++)
{
int rc;
int nitems_per_thread;
nitems_per_thread = nitems / nconsumers +
((i < nitems % nconsumers) ? 1 : 0);
rc =
globus_thread_create(
&thread,
NULL,
consumer,
(void *) nitems_per_thread);
if (rc != 0)
{
globus_stdio_lock();
{
printf("%04ld: main() - ERROR: "
"unable to create consumer thread %d\n",
thread_id,
i);
exit(1);
}
globus_stdio_unlock();
}
}
/*
* Wait for all threads to be started
*/
wait_for_all();
globus_stdio_lock();
{
printf("%04ld: main() - all threads started\n",
thread_id);
}
globus_stdio_unlock();
/*
* Wait for all threads to complete their work
*/
wait_for_all();
globus_stdio_lock();
{
printf("%04ld: main() - all threads have completed their work\n",
thread_id);
}
globus_stdio_unlock();
/*
* Wait for all thread id data to be destroyed
*/
while (thread_ids_destruct_cnt < nproducers + nconsumers)
{
globus_thread_yield();
}
globus_stdio_lock();
{
printf("%04ld: main() - all threads terminated\n",
thread_id);
}
globus_stdio_unlock();
globus_cond_destroy(&common_cond);
globus_mutex_destroy(&common_mutex);
globus_cond_destroy(&queue_cond);
globus_mutex_destroy(&queue_mutex);
globus_fifo_destroy(&queue);
globus_module_deactivate(GLOBUS_COMMON_MODULE);
exit(0);
}
int main(int argc, char *argv[])
{
char * callback_contact;
char * job_contact;
char * rm_contact;
monitor_t monitor;
int rc = 0;
LTDL_SET_PRELOADED_SYMBOLS();
printf("1..1\n");
rm_contact = getenv("CONTACT_STRING");
if (argc == 2)
{
rm_contact = argv[1];
}
if (rm_contact == NULL)
{
fprintf(stderr, "Usage: %s resource-manager-contact\n", argv[0]);
exit(1);
}
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if(rc)
{
goto end;
}
rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE);
if(rc)
{
goto disable_modules;
}
globus_mutex_init(&monitor.mutex ,GLOBUS_NULL);
globus_cond_init(&monitor.cond, GLOBUS_NULL);
monitor.state = GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING;
rc = globus_gram_client_callback_allow(gram_state_callback,
&monitor,
&callback_contact);
if(rc != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Error creating callback contact %s.\n",
globus_gram_client_error_string(rc));
goto error_exit;
}
globus_mutex_lock(&monitor.mutex);
rc = globus_gram_client_job_request(
rm_contact,
"&(executable=/bin/sleep)(arguments=300)",
GLOBUS_GRAM_PROTOCOL_JOB_STATE_ALL,
callback_contact,
&job_contact);
if(rc != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Error submitting job request %s.\n",
globus_gram_client_error_string(rc));
goto destroy_callback_contact;
}
while(monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE &&
monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED &&
monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
if(monitor.state == GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE)
{
rc = globus_gram_client_job_cancel(job_contact);
if(rc != GLOBUS_SUCCESS)
{
fprintf(stderr,
"Error cancelling job %s.\n",
globus_gram_client_error_string(rc));
goto destroy_callback_contact;
}
}
while(monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE &&
monitor.state != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
rc = monitor.errorcode;
if(rc == GLOBUS_GRAM_PROTOCOL_ERROR_USER_CANCELLED)
{
rc = GLOBUS_SUCCESS;
}
destroy_callback_contact:
globus_mutex_unlock(&monitor.mutex);
globus_gram_client_callback_disallow(callback_contact);
free(callback_contact);
free(job_contact);
error_exit:
globus_mutex_destroy(&monitor.mutex);
globus_cond_destroy(&monitor.cond);
disable_modules:
globus_module_deactivate_all();
end:
printf("%s - cancel-test\n", rc == 0 ? "ok" : "not ok");
return rc;
}
static
int
globus_l_job_manager_module_activate(void)
{
time_t timestamp_val;
globus_l_job_manager_logfile_state_t *
logfile_state;
int rc;
globus_reltime_t delay;
globus_result_t result;
char * scheduler;
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto activate_common_failed;
}
rc = globus_mutex_init(&globus_l_job_manager_mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto mutex_init_failed;
}
rc = globus_cond_init(&globus_l_job_manager_cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto cond_init_failed;
}
shutdown_called = GLOBUS_FALSE;
callback_count = 0;
GlobusDebugInit(
SEG_JOB_MANAGER,
SEG_JOB_MANAGER_DEBUG_INFO
SEG_JOB_MANAGER_DEBUG_WARN
SEG_JOB_MANAGER_DEBUG_ERROR
SEG_JOB_MANAGER_DEBUG_TRACE);
logfile_state = calloc(1, sizeof(globus_l_job_manager_logfile_state_t));
if (logfile_state == NULL)
{
goto calloc_state_failed;
}
/* Configuration info */
result = globus_scheduler_event_generator_get_timestamp(×tamp_val);
if (result != GLOBUS_SUCCESS)
{
goto get_timestamp_failed;
}
if (timestamp_val != 0)
{
if (globus_libc_gmtime_r(
×tamp_val,
&logfile_state->start_timestamp) == NULL)
{
goto gmtime_failed;
}
}
scheduler = globus_libc_getenv(JOB_MANAGER_SEG_SCHEDULER);
if (scheduler == NULL)
{
SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_ERROR,
("Error: %s not set\n", JOB_MANAGER_SEG_SCHEDULER));
result = GLOBUS_FAILURE;
goto get_scheduler_failed;
}
if (getenv(JOB_MANAGER_SEG_LOG_PATH))
{
logfile_state->log_dir = strdup(getenv(JOB_MANAGER_SEG_LOG_PATH));
}
else
{
char * log_dir_pattern = globus_common_create_string(
"${localstatedir}/lib/globus/globus-seg-%s", scheduler);
globus_eval_path(log_dir_pattern, &logfile_state->log_dir);
free(log_dir_pattern);
}
if (logfile_state->log_dir == NULL)
{
SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_ERROR,
("Error: out of memory\n"));
goto get_path_failed;
}
/* Convert timestamp to filename */
rc = globus_l_job_manager_find_logfile(logfile_state);
if (rc == GLOBUS_SUCCESS)
{
logfile_state->fp = fopen(logfile_state->path, "r");
if (logfile_state->fp == NULL)
{
rc = SEG_JOB_MANAGER_ERROR_OUT_OF_MEMORY;
goto fopen_failed;
}
GlobusTimeReltimeSet(delay, 0, 0);
}
else if(rc == SEG_JOB_MANAGER_ERROR_LOG_NOT_PRESENT)
{
GlobusTimeReltimeSet(delay, 1, 0);
}
else
{
goto bad_log_path;
}
result = globus_callback_register_oneshot(
&logfile_state->callback,
&delay,
globus_l_job_manager_poll_callback,
logfile_state);
if (result != GLOBUS_SUCCESS)
{
goto oneshot_failed;
}
callback_count++;
return 0;
oneshot_failed:
if (logfile_state->fp)
{
fclose(logfile_state->fp);
}
fopen_failed:
if (logfile_state->path)
{
free(logfile_state->path);
}
bad_log_path:
free(logfile_state->log_dir);
get_path_failed:
get_scheduler_failed:
get_timestamp_failed:
gmtime_failed:
free(logfile_state);
calloc_state_failed:
globus_cond_destroy(&globus_l_job_manager_cond);
cond_init_failed:
globus_mutex_destroy(&globus_l_job_manager_mutex);
mutex_init_failed:
globus_module_deactivate(GLOBUS_COMMON_MODULE);
activate_common_failed:
return 1;
}
int
main(int argc, char *argv[])
{
int rc;
int i;
struct monitor_t monitor;
if (argc < 3)
{
fprintf(stderr, "Usage: %s RESOURCE-MANAGER-CONTACT RSL-SPEC...\n",
argv[0]);
rc = 1;
goto out;
}
printf("Submiting %d jobs to %s\n", argc-2, argv[1]);
/*
* Always activate the GLOBUS_GRAM_CLIENT_MODULE prior to using any
* functions from the GRAM Client API or behavior is undefined.
*/
rc = globus_module_activate(GLOBUS_GRAM_CLIENT_MODULE);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Error activating %s because %s (Error %d)\n",
GLOBUS_GRAM_CLIENT_MODULE->module_name,
globus_gram_client_error_string(rc),
rc);
goto out;
}
rc = globus_mutex_init(&monitor.mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Error initializing mutex %d\n", rc);
goto deactivate;
}
rc = globus_cond_init(&monitor.cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Error initializing condition variable %d\n", rc);
goto destroy_mutex;
}
monitor.submit_pending = 0;
/* Submits jobs from argv[2] until end of the argv array. At most
* CONCURRENT_SUBMITS will be pending at any given time.
*/
globus_mutex_lock(&monitor.mutex);
for (i = 2; i < argc; i++)
{
/* This throttles the number of concurrent job submissions */
while (monitor.submit_pending >= CONCURRENT_SUBMITS)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
/* When the job has been submitted, the example_submit_callback
* will be called, either from another thread or from a
* globus_cond_wait in a nonthreaded build
*/
rc = globus_gram_client_register_job_request(
argv[1], argv[i], 0, NULL, NULL, example_submit_callback,
&monitor);
if (rc != GLOBUS_SUCCESS)
{
fprintf(stderr, "Unable to submit job %s because %s (Error %d)\n",
argv[i], globus_gram_client_error_string(rc), rc);
}
else
{
monitor.submit_pending++;
}
}
/* Wait until the example_submit_callback function has been called for
* each job submission
*/
while (monitor.submit_pending > 0)
{
globus_cond_wait(&monitor.cond, &monitor.mutex);
}
globus_mutex_unlock(&monitor.mutex);
printf("Submitted %d jobs (%d successfully)\n",
argc-2, monitor.successful_submits);
globus_cond_destroy(&monitor.cond);
destroy_mutex:
globus_mutex_destroy(&monitor.mutex);
deactivate:
/*
* Deactivating the module allows it to free memory and close network
* connections.
*/
rc = globus_module_deactivate(GLOBUS_GRAM_CLIENT_MODULE);
out:
return rc;
}
