/* get the next process in the snapshot */
static int snapshot_next_process( struct snapshot *snapshot, struct next_process_reply *reply )
{
struct process_snapshot *ptr;
struct process_dll *exe_module;
if (!snapshot->process_count)
{
set_error( STATUS_INVALID_PARAMETER ); /* FIXME */
return 0;
}
if (snapshot->process_pos >= snapshot->process_count)
{
set_error( STATUS_NO_MORE_FILES );
return 0;
}
ptr = &snapshot->processes[snapshot->process_pos++];
reply->count = ptr->count;
reply->pid = get_process_id( ptr->process );
reply->ppid = ptr->process->parent ? get_process_id( ptr->process->parent ) : 0;
reply->threads = ptr->threads;
reply->priority = ptr->priority;
reply->handles = ptr->handles;
reply->unix_pid = ptr->process->unix_pid;
if ((exe_module = get_process_exe_module( ptr->process )) && exe_module->filename)
{
data_size_t len = min( exe_module->namelen, get_reply_max_size() );
set_reply_data( exe_module->filename, len );
}
return 1;
}
process* create_child_process(process* parent){
void *addr = k_malloc(sizeof(process));
process* child = addr;
child->self_memory = (uint64_t)addr;
child->pid = get_process_id();
child->ppid = parent->pid;
child->timer_val = 0;
child->state = TASK_INTERRUPTIBLE;
child->memory = NULL;
child->pp = parent;
child->p_cache = 0;
child->kernel_stack = k_malloc_stack(4095);
clear_registers(child->reg);
child->cr3 = create_user_process_table();
child->memory = create_mm_object(child);
copy_vma(parent,child);
copy_fdtable(parent,child);
//child->fdtable = parent->fdtable;
child->maxfd = parent->maxfd;
copy_memory(parent,child);
set_COW_bits(child,parent);
child->start_exec = parent->start_exec;
copy_registers(child,parent);
strcpy(parent->p_name,child->p_name);
child->env_set =0;
refresh_cr3();
return child;
}
static void kill_process_tree( DWORD pid, HANDLE process )
{
HANDLE process_snapshot_h = INVALID_HANDLE_VALUE;
if ( !pid )
pid = get_process_id( process );
process_snapshot_h = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
if ( INVALID_HANDLE_VALUE != process_snapshot_h )
{
BOOL ok = TRUE;
PROCESSENTRY32 pinfo;
pinfo.dwSize = sizeof( PROCESSENTRY32 );
for (
ok = Process32First( process_snapshot_h, &pinfo );
ok == TRUE;
ok = Process32Next( process_snapshot_h, &pinfo ) )
{
if ( pinfo.th32ParentProcessID == pid )
{
/* Found a child, recurse to kill it and anything else below it.
*/
HANDLE ph = OpenProcess( PROCESS_ALL_ACCESS, FALSE,
pinfo.th32ProcessID );
if ( NULL != ph )
{
kill_process_tree( pinfo.th32ProcessID, ph );
CloseHandle( ph );
}
}
}
CloseHandle( process_snapshot_h );
}
/* Now that the children are all dead, kill the root. */
TerminateProcess( process, -2 );
}
int parse_process_and_process_type(char *buffer, process_s *process)
{
int id, i;
/*check out TYPE_ID.*/
if ((id = get_process_id(buffer)) != -1)
{
*process = process_list[id];
return TYPE_ID;
}
/*check out TYPE_APP_NAME.*/
for(i = 0; i < process_count; i++)
{
if(strcmp(process_list[i].app_name, buffer) == 0)
{
*process = process_list[i];
return TYPE_APP_NAME;
}
}
/*check out TYPE_CMD.*/
if(parse_process(process, buffer) == -1)
{
return TYPE_ERR;
}
return TYPE_CMD;
}
void pkcs11_logger_log(const char* message, ...)
{
FILE *fw = NULL;
FILE *output = stdout;
va_list ap;
// Acquire exclusive access to the file
pkcs11_logger_lock_acquire();
va_start(ap, message);
// Determine log filename
char *log_file_name = getenv("PKCS11_LOGGER_LOG_FILE");
if (NULL == log_file_name)
log_file_name = DEFAULT_PKCS11_LOGGER_LOG_FILE;
// Open log file
fw = fopen(log_file_name, "a");
if (NULL != fw)
output = fw;
// Output message to log file or stdout
fprintf(output, "%0#10x : ", get_process_id());
fprintf(output, "%0#10x : ", get_thread_id());
vfprintf(output, message, ap);
fprintf(output, "\n");
// Cleanup
va_end(ap);
CALL_N_CLEAR(fclose, fw);
// Release exclusive access to the file
pkcs11_logger_lock_release();
}
inline random_seed_type default_random_seed() {
// long pid=get_process_id();
#if GRAEHL_USE_RANDOM_DEVICE
return boost::random_device().operator()();
#else
random_seed_type pid = (random_seed_type)get_process_id();
return (random_seed_type)std::time(0) ^ pid ^ (pid << 17);
#endif
}
boost::int64_t get_process_id(boost::exception_ptr const& e)
{
try {
boost::rethrow_exception(e);
}
catch (boost::exception const& be) {
return get_process_id(be);
}
}
void *
test_fun(void *parm)
{
int process_id = get_process_id();
int thread_id = ((struct parm *)parm)->id;
int count = ((struct parm *)parm)->count;
char *file_type = ((struct parm *)parm)->file_type;
char file_path[MAX_FILE_PATH] = TEST_FILE_PREFIX;
strcat(file_path, "test");
strcat(file_path, file_type);
strcat(file_path, "/");
strcat(file_path, file_type);
strcat(file_path, "_");
int fds[count];
char *buff[count];
size_t sizes[count];
printf("slave %d thread %d start to open file!\n", process_id, thread_id);
int i;
for(i = 0; i < count; i++) {
char file[MAX_FILE_PATH];
strcpy(file, file_path);
strcatn(file, i);
/* 需要在#include <fcntl.h>之前#define _GNU_SOURCE，NFS无对齐限制 */
if((fds[i] = open(file, O_RDONLY | O_DIRECT | O_SYNC)) == -1) {
printf("slave %d thread %d open failed!\n", process_id, thread_id);
return (void *)-2;
}
sizes[i] = lseek(fds[i], 0, SEEK_END);
lseek(fds[i], 0, SEEK_SET);
buff[i] = (char *)malloc(sizes[i]);
memset(buff[i], 0, sizes[i]);
}
struct timeval start, end;
printf("slave %d thread %d start to read file from disk!\n", process_id, thread_id);
gettimeofday(&start, NULL);
for(i = 0; i < count; i++) {
if (sizes[i] != read(fds[i], buff[i], sizes[i])) {
printf("slave %d thread %d disk read error!\n", process_id, thread_id);
return (void *)-3;
}
}
gettimeofday(&end, NULL);
double timeuse;
timeuse = 1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec - start.tv_usec;
timeuse /= 1000;
printf("use %lf microseconds to read %d %s files from disk\n",timeuse, count, file_type);
for(i = 0; i < count; i++) {
close(fds[i]);
}
printf("slave %d thread %d end!\n", process_id, thread_id);
return (void *)0;
}
int __get_semaphore_count( sem_id sem )
{
sem_info info;
int error;
error = get_semaphore_info( sem, get_process_id( NULL ), &info );
if( error < 0 )
return error;
return info.si_count;
}
void kill_error_report()
{
DWORD pid;
do {
if((pid = get_process_id("dwwin.exe"))!=0) {
fprintf(stderr," -- with error report (pid: %ld)\n",pid);
HANDLE hProcess = OpenProcess( PROCESS_ALL_ACCESS, FALSE, pid);
if(hProcess!=NULL) {
TerminateProcess(hProcess, 0);
Sleep(500);
while(get_process_id("dwwin.exe")==pid) {
fprintf(stderr,"wait for dwwin.exe to die...\n");
Sleep(500);
}
} else
fprintf(stderr,"do not have permission (%d)\n",
GetLastError());
}
} while(get_process_id("dwwin.exe")!=0);
}
static void
close_alert(HANDLE process)
{
DWORD pid = get_process_id(process);
/* If process already exited or we just cannot get its process id, do not
go any further */
if (pid)
{
PROCESS_HANDLE_ID p = {process, pid};
EnumWindows(&window_enum, (LPARAM) &p);
}
}
inline std::vector< HWND > get_window_from_process_id( process_id const& id )
{
auto const wnds = enum_windows();
std::vector< HWND > result;
for( HWND w : wnds ) {
if( id == get_process_id( w ) ) {
result.push_back( w );
}
}
return result;
}
int find_next_index( int proc_index,
int c_index,
mca_io_ompio_file_t *fh,
local_io_array *global_iov_array,
int global_iov_count,
int *sorted){
int i;
for(i=c_index+1; i<global_iov_count;i++){
if (get_process_id(global_iov_array[sorted[i]].process_id,
fh) == proc_index)
return i;
}
return -1;
}
/* 初始化log文件 */
int
init_logger(char *path, int thread_num)
{
int i;
char path_buf[MAX_PATH_LENGTH];
strcpy(path_buf, path);
char *ptr = path_buf + strlen(path_buf);
if (ptr[-1] != '/') {
*ptr++ = '/'; /* 添加/ */
*ptr = 0;
}
/* 构建相应的文件名 */
int pid;
if ((pid = get_process_id()) == 0) {
strcat(path_buf, "master");
} else {
strcat(path_buf, "slave");
strcatn(path_buf, pid);
}
strcat(path_buf, "thread");
ptr = path_buf + strlen(path_buf);
for (i = 0; i < thread_num; i++) {
int pow = 1;
int j = i / 10;
while(j) {
pow++;
j /= 10;
}
j = i;
ptr[pow--] = '\0';
while (pow >= 0) {
ptr[pow--] = '0' + (j % 10);
j /= 10;
}
/* 打开文件，如不存在，则创建，目录之前应存在 */
if (!(log_file[i] = fopen(strcat(path_buf, ".log"), "a"))) {
return -1;
}
}
/* 初始化每线程变量log id */
return pthread_key_create(&log_id, NULL);
}
void signal_safe_write(Slice data, bool add_header) {
auto old_errno = errno;
if (add_header) {
constexpr size_t HEADER_BUF_SIZE = 100;
char header[HEADER_BUF_SIZE];
char *header_end = header + HEADER_BUF_SIZE;
char *header_begin = header_end;
signal_safe_append_int(&header_begin, "time", static_cast<int>(std::time(nullptr)));
signal_safe_append_int(&header_begin, "pid", get_process_id());
signal_safe_write_data(Slice(header_begin, header_end));
}
signal_safe_write_data(data);
errno = old_errno;
}
cell AMX_NATIVE_CALL kill_proc(AMX *amx, cell *params) {
int len;
cell *addr = NULL;
amx_GetAddr(amx, params [1], &addr);
amx_StrLen(addr, &len);
char* proc = malloc (++len);
amx_GetString(proc, addr, 0, len);
int pid = get_process_id (proc);
if (pid == 0) {
logprintf ("Process %s not found!", proc);
free (proc);
return 0;
}
logprintf ("Process %s | ID: %d", proc, pid);
kill (pid, SIGKILL) != 0 ? logprintf ("Need root access for kill %s!", proc) : logprintf ("Process %s <%d> was successfully killed!", proc, pid);
free (proc);
return 1;
}
/* get the next thread in the snapshot */
static int snapshot_next_thread( struct snapshot *snapshot, struct next_thread_reply *reply )
{
struct thread_snapshot *ptr;
if (!snapshot->thread_count)
{
set_error( STATUS_INVALID_PARAMETER ); /* FIXME */
return 0;
}
if (snapshot->thread_pos >= snapshot->thread_count)
{
set_error( STATUS_NO_MORE_FILES );
return 0;
}
ptr = &snapshot->threads[snapshot->thread_pos++];
reply->count = ptr->count;
reply->pid = get_process_id( ptr->thread->process );
reply->tid = get_thread_id( ptr->thread );
reply->base_pri = ptr->priority;
reply->delta_pri = 0; /* FIXME */
return 1;
}
void
stackdump(void)
{
int pid, core_pid;
/* get name now -- will be same for children */
char *exec_name = get_application_name();
char core_name[128];
char tmp_name[128];
snprintf(tmp_name, 128, "%s.%d", TEMPORARY_FILENAME, get_process_id());
#ifdef VMX86_SERVER
if (os_in_vmkernel_userworld()) {
return; /* no local gdb, no multithreaded fork */
}
#endif
#if VERBOSE
SYSLOG_INTERNAL_ERROR("about to fork parent %d to dump core", get_process_id());
#endif
/* Fork a child to dump core */
pid = fork_syscall();
if (pid == 0) { /* child */
#if VERBOSE
SYSLOG_INTERNAL_ERROR("about to dump core in process %d parent %d thread " TIDFMT
"",
get_process_id(), get_parent_id(), get_thread_id());
#endif
/* We used to use abort here, but that had lots of complications with
* pthreads and libc, so now we just dereference NULL.
*/
if (!set_default_signal_action(SIGSEGV)) {
SYSLOG_INTERNAL_ERROR("ERROR in setting handler");
exit_process_syscall(1);
}
*(volatile int *)NULL = 0;
#if VERBOSE
SYSLOG_INTERNAL_ERROR("about to exit process %d", get_process_id());
#endif
exit_process_syscall(0);
} else if (pid == -1) {
SYSLOG_INTERNAL_ERROR("ERROR: could not fork to dump core");
exit_process_syscall(1);
}
#if VERBOSE
SYSLOG_INTERNAL_ERROR("parent %d %d waiting for child %d", get_process_id(),
get_thread_id(), pid);
#endif
/* Parent continues */
core_pid = pid;
while (wait_syscall(NULL) != pid) {
/* wait for core to be dumped */
}
#if VERBOSE
SYSLOG_INTERNAL_ERROR("about to fork 2nd child to run gdb");
#endif
/* Fork a 2nd child to run gdb */
pid = fork_syscall();
if (pid == 0) { /* child */
file_t fp;
int fd;
const char *argv[16];
int i;
int execve_errno;
/* Open a temporary file for the input: the "where" command */
fp = os_open(tmp_name, OS_OPEN_REQUIRE_NEW | OS_OPEN_WRITE);
os_write(fp, DEBUGGER_COMMAND, strlen(DEBUGGER_COMMAND));
os_close(fp);
fd = open_syscall(tmp_name, O_RDONLY, 0);
if (fd < 0) {
SYSLOG_INTERNAL_ERROR("ERROR: open failed on temporary file");
exit_process_syscall(1);
}
#if !BATCH_MODE
/* Redirect stdin from the temporary file */
close_syscall(0); /* close stdin */
dup_syscall(fd); /* replace file descriptor 0 with reference to temp file */
#endif
close_syscall(fd); /* close the other reference to temporary file */
/* Find the core file */
strncpy(core_name, CORE_NAME, 127);
core_name[127] = '\0'; /* if max no null */
fd = open_syscall(core_name, O_RDONLY, 0);
if (fd < 0) {
snprintf(core_name, 128, "%s.%d", CORE_NAME, core_pid);
SYSLOG_INTERNAL_ERROR("core not found, trying %s", core_name);
fd = open_syscall(core_name, O_RDONLY, 0);
if (fd < 0) {
SYSLOG_INTERNAL_ERROR("ERROR: no core file found!");
exit_process_syscall(1);
}
}
close_syscall(fd);
/* avoid running the debugger under us!
* FIXME: just remove our libraries, instead of entire env var?
*/
unsetenv("LD_PRELOAD");
SYSLOG_INTERNAL_ERROR("-------------------------------------------");
SYSLOG_INTERNAL_ERROR("stackdump: --- now running the debugger ---");
SYSLOG_INTERNAL_ERROR("%s %s %s %s", DEBUGGER, QUIET_MODE, exec_name, core_name);
SYSLOG_INTERNAL_ERROR("-------------------------------------------");
i = 0;
/* We rely on /usr/bin/env to do the PATH search for gdb on our behalf.
*/
argv[i++] = "/usr/bin/env";
argv[i++] = DEBUGGER;
argv[i++] = QUIET_MODE;
#if BATCH_MODE
argv[i++] = "-x";
argv[i++] = tmp_name;
argv[i++] = "-batch";
#endif
argv[i++] = exec_name;
argv[i++] = core_name;
argv[i++] = NULL;
execve_errno = execve_syscall("/usr/bin/env", argv, our_environ);
SYSLOG_INTERNAL_ERROR("ERROR: execve failed for debugger: %d", -execve_errno);
exit_process_syscall(1);
} else if (pid == -1) {
SYSLOG_INTERNAL_ERROR("ERROR: could not fork to run debugger");
exit_process_syscall(1);
}
/* Parent continues */
/* while(wait(NULL)>0) waits for all children, and could hang, so: */
while (wait_syscall(NULL) != pid) {
/* empty loop */
}
/* Wait for these children to complete before returning */
while (wait_syscall(NULL) > 0) {
/* empty loop */
}
os_delete_file(tmp_name); /* clean up the temporary file */
SYSLOG_INTERNAL_ERROR("-------------------------------------------");
}
uint32_t get_process_h32()
{
const pid_type p = get_process_id();
return hash32(&p, sizeof(p));
}
DWORD get_ntvdm_pid()
{
return get_process_id("ntvdm.exe");
}
void __init tegra210_init_speedo_data(struct tegra_sku_info *sku_info)
{
int cpu_speedo[3], soc_speedo[3], cpu_iddq, gpu_iddq, soc_iddq;
unsigned int index;
u8 speedo_revision;
BUILD_BUG_ON(ARRAY_SIZE(cpu_process_speedos) !=
THRESHOLD_INDEX_COUNT);
BUILD_BUG_ON(ARRAY_SIZE(gpu_process_speedos) !=
THRESHOLD_INDEX_COUNT);
BUILD_BUG_ON(ARRAY_SIZE(soc_process_speedos) !=
THRESHOLD_INDEX_COUNT);
/* Read speedo/IDDQ fuses */
cpu_speedo[0] = tegra_fuse_read_early(FUSE_CPU_SPEEDO_0);
cpu_speedo[1] = tegra_fuse_read_early(FUSE_CPU_SPEEDO_1);
cpu_speedo[2] = tegra_fuse_read_early(FUSE_CPU_SPEEDO_2);
soc_speedo[0] = tegra_fuse_read_early(FUSE_SOC_SPEEDO_0);
soc_speedo[1] = tegra_fuse_read_early(FUSE_SOC_SPEEDO_1);
soc_speedo[2] = tegra_fuse_read_early(FUSE_CPU_SPEEDO_2);
cpu_iddq = tegra_fuse_read_early(FUSE_CPU_IDDQ) * 4;
soc_iddq = tegra_fuse_read_early(FUSE_SOC_IDDQ) * 4;
gpu_iddq = tegra_fuse_read_early(FUSE_GPU_IDDQ) * 5;
/*
* Determine CPU, GPU and SoC speedo values depending on speedo fusing
* revision. Note that GPU speedo value is fused in CPU_SPEEDO_2.
*/
speedo_revision = get_speedo_revision();
pr_info("Speedo Revision %u\n", speedo_revision);
if (speedo_revision >= 3) {
sku_info->cpu_speedo_value = cpu_speedo[0];
sku_info->gpu_speedo_value = cpu_speedo[2];
sku_info->soc_speedo_value = soc_speedo[0];
} else if (speedo_revision == 2) {
sku_info->cpu_speedo_value = (-1938 + (1095 * cpu_speedo[0] / 100)) / 10;
sku_info->gpu_speedo_value = (-1662 + (1082 * cpu_speedo[2] / 100)) / 10;
sku_info->soc_speedo_value = ( -705 + (1037 * soc_speedo[0] / 100)) / 10;
} else {
sku_info->cpu_speedo_value = 2100;
sku_info->gpu_speedo_value = cpu_speedo[2] - 75;
sku_info->soc_speedo_value = 1900;
}
if ((sku_info->cpu_speedo_value <= 0) ||
(sku_info->gpu_speedo_value <= 0) ||
(sku_info->soc_speedo_value <= 0)) {
WARN(1, "speedo value not fused\n");
return;
}
rev_sku_to_speedo_ids(sku_info, speedo_revision, &index);
sku_info->gpu_process_id = get_process_id(sku_info->gpu_speedo_value,
gpu_process_speedos[index],
GPU_PROCESS_CORNERS);
sku_info->cpu_process_id = get_process_id(sku_info->cpu_speedo_value,
cpu_process_speedos[index],
CPU_PROCESS_CORNERS);
sku_info->soc_process_id = get_process_id(sku_info->soc_speedo_value,
soc_process_speedos[index],
SOC_PROCESS_CORNERS);
pr_debug("Tegra GPU Speedo ID=%d, Speedo Value=%d\n",
sku_info->gpu_speedo_id, sku_info->gpu_speedo_value);
}
boost::int64_t get_process_id(hpx::exception const& e)
{
return get_process_id(dynamic_cast<boost::exception const&>(e));
}
int
mca_fcoll_static_file_write_all (mca_io_ompio_file_t *fh,
void *buf,
int count,
struct ompi_datatype_t *datatype,
ompi_status_public_t *status)
{
size_t max_data = 0, bytes_per_cycle=0;
struct iovec *iov=NULL, *decoded_iov=NULL;
uint32_t iov_count=0, iov_index=0;
int i=0,j=0,l=0, temp_index;
int ret=OMPI_SUCCESS, cycles, local_cycles, *bytes_per_process=NULL;
int index, *disp_index=NULL, **blocklen_per_process=NULL;
int *iovec_count_per_process=NULL, *displs=NULL;
size_t total_bytes_written=0;
MPI_Aint **displs_per_process=NULL, *memory_displacements=NULL;
MPI_Aint bytes_to_write_in_cycle=0, global_iov_count=0, global_count=0;
local_io_array *local_iov_array =NULL, *global_iov_array=NULL;
local_io_array *file_offsets_for_agg=NULL;
int *sorted=NULL, *sorted_file_offsets=NULL, temp_pindex, *temp_disp_index=NULL;
char *send_buf=NULL, *global_buf=NULL;
int iov_size=0, current_position=0, *current_index=NULL;
int *bytes_remaining=NULL, entries_per_aggregator=0;
ompi_datatype_t **recvtype = NULL;
MPI_Request *send_req=NULL, *recv_req=NULL;
/* For creating datatype of type io_array */
int blocklen[3] = {1, 1, 1};
int static_num_io_procs=1;
OPAL_PTRDIFF_TYPE d[3], base;
ompi_datatype_t *types[3];
ompi_datatype_t *io_array_type=MPI_DATATYPE_NULL;
/*----------------------------------------------*/
#if OMPIO_FCOLL_WANT_TIME_BREAKDOWN
double write_time = 0.0, start_write_time = 0.0, end_write_time = 0.0;
double comm_time = 0.0, start_comm_time = 0.0, end_comm_time = 0.0;
double exch_write = 0.0, start_exch = 0.0, end_exch = 0.0;
mca_io_ompio_print_entry nentry;
#endif
#if DEBUG_ON
MPI_Aint gc_in;
#endif
// if (opal_datatype_is_contiguous_memory_layout(&datatype->super,1)) {
// fh->f_flags |= OMPIO_CONTIGUOUS_MEMORY;
// }
/* In case the data is not contigous in memory, decode it into an iovec */
if (! (fh->f_flags & OMPIO_CONTIGUOUS_MEMORY)) {
fh->f_decode_datatype ((struct mca_io_ompio_file_t *)fh,
datatype,
count,
buf,
&max_data,
&decoded_iov,
&iov_count);
}
else {
max_data = count * datatype->super.size;
}
if ( MPI_STATUS_IGNORE != status ) {
status->_ucount = max_data;
}
fh->f_get_num_aggregators ( & static_num_io_procs );
fh->f_set_aggregator_props ((struct mca_io_ompio_file_t *)fh,
static_num_io_procs,
max_data);
/* io_array datatype for using in communication*/
types[0] = &ompi_mpi_long.dt;
types[1] = &ompi_mpi_long.dt;
types[2] = &ompi_mpi_int.dt;
d[0] = (OPAL_PTRDIFF_TYPE)&local_iov_array[0];
d[1] = (OPAL_PTRDIFF_TYPE)&local_iov_array[0].length;
d[2] = (OPAL_PTRDIFF_TYPE)&local_iov_array[0].process_id;
base = d[0];
for (i=0 ; i<3 ; i++) {
d[i] -= base;
}
ompi_datatype_create_struct (3,
blocklen,
d,
types,
&io_array_type);
ompi_datatype_commit (&io_array_type);
/* #########################################################*/
ret = fh->f_generate_current_file_view((struct mca_io_ompio_file_t *)fh,
max_data,
&iov,
&iov_size);
if (ret != OMPI_SUCCESS){
fprintf(stderr,"Current File View Generation Error\n");
goto exit;
}
if (0 == iov_size){
iov_size = 1;
}
local_iov_array = (local_io_array *)malloc (iov_size * sizeof(local_io_array));
if ( NULL == local_iov_array){
fprintf(stderr,"local_iov_array allocation error\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
for (j=0; j < iov_size; j++){
local_iov_array[j].offset = (OMPI_MPI_OFFSET_TYPE)(intptr_t)
iov[j].iov_base;
local_iov_array[j].length = (size_t)iov[j].iov_len;
local_iov_array[j].process_id = fh->f_rank;
}
fh->f_get_bytes_per_agg ( (int *) &bytes_per_cycle);
local_cycles = ceil((double)max_data/bytes_per_cycle);
ret = fh->f_comm->c_coll.coll_allreduce (&local_cycles,
&cycles,
1,
MPI_INT,
MPI_MAX,
fh->f_comm,
fh->f_comm->c_coll.coll_allreduce_module);
if (OMPI_SUCCESS != ret){
fprintf(stderr,"local cycles allreduce!\n");
goto exit;
}
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
disp_index = (int *)malloc (fh->f_procs_per_group * sizeof (int));
if (NULL == disp_index) {
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
bytes_per_process = (int *) malloc (fh->f_procs_per_group * sizeof(int ));
if (NULL == bytes_per_process){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
bytes_remaining = (int *) malloc (fh->f_procs_per_group * sizeof(int));
if (NULL == bytes_remaining){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
current_index = (int *) malloc (fh->f_procs_per_group * sizeof(int));
if (NULL == current_index){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
blocklen_per_process = (int **)malloc (fh->f_procs_per_group * sizeof (int*));
if (NULL == blocklen_per_process) {
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
displs_per_process = (MPI_Aint **)
malloc (fh->f_procs_per_group * sizeof (MPI_Aint*));
if (NULL == displs_per_process) {
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
for(i=0;i<fh->f_procs_per_group;i++){
current_index[i] = 0;
bytes_remaining[i] =0;
blocklen_per_process[i] = NULL;
displs_per_process[i] = NULL;
}
}
iovec_count_per_process = (int *) malloc (fh->f_procs_per_group * sizeof(int));
if (NULL == iovec_count_per_process){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
displs = (int *) malloc (fh->f_procs_per_group * sizeof(int));
if (NULL == displs){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
ret = fh->f_allgather_array (&iov_size,
1,
MPI_INT,
iovec_count_per_process,
1,
MPI_INT,
fh->f_aggregator_index,
fh->f_procs_in_group,
fh->f_procs_per_group,
fh->f_comm);
if( OMPI_SUCCESS != ret){
fprintf(stderr,"iov size allgatherv array!\n");
goto exit;
}
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
displs[0] = 0;
global_iov_count = iovec_count_per_process[0];
for (i=1 ; i<fh->f_procs_per_group ; i++) {
global_iov_count += iovec_count_per_process[i];
displs[i] = displs[i-1] + iovec_count_per_process[i-1];
}
}
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
global_iov_array = (local_io_array *) malloc (global_iov_count *
sizeof(local_io_array));
if (NULL == global_iov_array){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
}
ret = fh->f_gatherv_array (local_iov_array,
iov_size,
io_array_type,
global_iov_array,
iovec_count_per_process,
displs,
io_array_type,
fh->f_aggregator_index,
fh->f_procs_in_group,
fh->f_procs_per_group,
fh->f_comm);
if (OMPI_SUCCESS != ret){
fprintf(stderr,"global_iov_array gather error!\n");
goto exit;
}
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
if ( 0 == global_iov_count){
global_iov_count = 1;
}
sorted = (int *)malloc (global_iov_count * sizeof(int));
if (NULL == sorted) {
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
local_heap_sort (global_iov_array, global_iov_count, sorted);
}
#if DEBUG_ON
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
for (gc_in=0; gc_in<global_iov_count; gc_in++){
printf("%d: Offset[%ld]: %lld, Length[%ld]: %ld\n",
global_iov_array[gc_in].process_id,
gc_in, global_iov_array[gc_in].offset,
gc_in, global_iov_array[gc_in].length);
}
}
#endif
#if OMPIO_FCOLL_WANT_TIME_BREAKDOWN
start_exch = MPI_Wtime();
#endif
for (index = 0; index < cycles; index++){
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
if (NULL == recvtype){
recvtype = (ompi_datatype_t **)
malloc (fh->f_procs_per_group * sizeof(ompi_datatype_t *));
if (NULL == recvtype) {
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
}
for(l=0;l<fh->f_procs_per_group;l++){
disp_index[l] = 1;
if (NULL != blocklen_per_process[l]){
free(blocklen_per_process[l]);
blocklen_per_process[l] = NULL;
}
if (NULL != displs_per_process[l]){
free(displs_per_process[l]);
displs_per_process[l] = NULL;
}
blocklen_per_process[l] = (int *) calloc (1, sizeof(int));
if (NULL == blocklen_per_process[l]) {
opal_output (1, "OUT OF MEMORY for blocklen\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
displs_per_process[l] = (MPI_Aint *) calloc (1, sizeof(MPI_Aint));
if (NULL == displs_per_process[l]){
opal_output (1, "OUT OF MEMORY for displs\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
}
if (NULL != sorted_file_offsets){
free(sorted_file_offsets);
sorted_file_offsets = NULL;
}
if(NULL != file_offsets_for_agg){
free(file_offsets_for_agg);
file_offsets_for_agg = NULL;
}
if (NULL != memory_displacements){
free(memory_displacements);
memory_displacements = NULL;
}
}
if (local_cycles > index) {
if ((index == local_cycles-1) && (max_data % bytes_per_cycle)) {
bytes_to_write_in_cycle = max_data % bytes_per_cycle;
}
else if (max_data <= bytes_per_cycle) {
bytes_to_write_in_cycle = max_data;
}
else {
bytes_to_write_in_cycle = bytes_per_cycle;
}
}
else {
bytes_to_write_in_cycle = 0;
}
#if DEBUG_ON
/* if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {*/
printf ("***%d: CYCLE %d Bytes %ld**********\n",
fh->f_rank,
index,
bytes_to_write_in_cycle);
/* }*/
#endif
/**********************************************************
**Gather the Data from all the processes at the writers **
*********************************************************/
/* gather from each process how many bytes each will be sending */
fh->f_gather_array (&bytes_to_write_in_cycle,
1,
MPI_INT,
bytes_per_process,
1,
MPI_INT,
fh->f_aggregator_index,
fh->f_procs_in_group,
fh->f_procs_per_group,
fh->f_comm);
/*
For each aggregator
it needs to get bytes_to_write_in_cycle from each process
in group which adds up to bytes_per_cycle
*/
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
for (i=0;i<fh->f_procs_per_group; i++){
/* printf("bytes_per_process[%d]: %d\n", i, bytes_per_process[i]);
*/
#if DEBUG_ON
printf ("%d : bytes_per_process : %d\n",
fh->f_procs_in_group[i],
bytes_per_process[i]);
#endif
while (bytes_per_process[i] > 0){
if (get_process_id(global_iov_array[sorted[current_index[i]]].process_id,
fh) == i){ /* current id owns this entry!*/
/*Add and subtract length and create
blocklength and displs array*/
if (bytes_remaining[i]){ /*Remaining bytes in the current entry of
the global offset array*/
if (bytes_remaining[i] <= bytes_per_process[i]){
blocklen_per_process[i][disp_index[i] - 1] = bytes_remaining[i];
displs_per_process[i][disp_index[i] - 1] =
global_iov_array[sorted[current_index[i]]].offset +
(global_iov_array[sorted[current_index[i]]].length
- bytes_remaining[i]);
blocklen_per_process[i] = (int *) realloc
((void *)blocklen_per_process[i], (disp_index[i]+1)*sizeof(int));
displs_per_process[i] = (MPI_Aint *)realloc
((void *)displs_per_process[i], (disp_index[i]+1)*sizeof(MPI_Aint));
bytes_per_process[i] -= bytes_remaining[i];
blocklen_per_process[i][disp_index[i]] = 0;
displs_per_process[i][disp_index[i]] = 0;
bytes_remaining[i] = 0;
disp_index[i] += 1;
/* This entry has been used up, we need to move to the
next entry of this process and make current_index point there*/
current_index[i] = find_next_index(i,
current_index[i],
fh,
global_iov_array,
global_iov_count,
sorted);
if (current_index[i] == -1){
/* No more entries left, so Its all done! exit!*/
break;
}
continue;
}
else{
blocklen_per_process[i][disp_index[i] - 1] = bytes_per_process[i];
displs_per_process[i][disp_index[i] - 1] =
global_iov_array[sorted[current_index[i]]].offset +
(global_iov_array[sorted[current_index[i]]].length
- bytes_remaining[i]);
bytes_remaining[i] -= bytes_per_process[i];
bytes_per_process[i] = 0;
break;
}
}
else{
if (bytes_per_process[i] <
global_iov_array[sorted[current_index[i]]].length){
blocklen_per_process[i][disp_index[i] - 1] =
bytes_per_process[i];
displs_per_process[i][disp_index[i] - 1] =
global_iov_array[sorted[current_index[i]]].offset;
bytes_remaining[i] =
global_iov_array[sorted[current_index[i]]].length -
bytes_per_process[i];
bytes_per_process[i] = 0;
break;
}
else {
blocklen_per_process[i][disp_index[i] - 1] =
global_iov_array[sorted[current_index[i]]].length;
displs_per_process[i][disp_index[i] - 1] =
global_iov_array[sorted[current_index[i]]].offset;
blocklen_per_process[i] =
(int *) realloc ((void *)blocklen_per_process[i], (disp_index[i]+1)*sizeof(int));
displs_per_process[i] = (MPI_Aint *)realloc
((void *)displs_per_process[i], (disp_index[i]+1)*sizeof(MPI_Aint));
blocklen_per_process[i][disp_index[i]] = 0;
displs_per_process[i][disp_index[i]] = 0;
disp_index[i] += 1;
bytes_per_process[i] -=
global_iov_array[sorted[current_index[i]]].length;
current_index[i] = find_next_index(i,
current_index[i],
fh,
global_iov_array,
global_iov_count,
sorted);
if (current_index[i] == -1){
break;
}
}
}
}
else{
current_index[i] = find_next_index(i,
current_index[i],
fh,
global_iov_array,
global_iov_count,
sorted);
if (current_index[i] == -1){
bytes_per_process[i] = 0; /* no more entries left
to service this request*/
continue;
}
}
}
}
entries_per_aggregator=0;
for (i=0;i<fh->f_procs_per_group;i++){
for (j=0;j<disp_index[i];j++){
if (blocklen_per_process[i][j] > 0){
entries_per_aggregator++;
#if DEBUG_ON
printf("%d sends blocklen[%d]: %d, disp[%d]: %ld to %d\n",
fh->f_procs_in_group[i],j,
blocklen_per_process[i][j],j,
displs_per_process[i][j],
fh->f_rank);
#endif
}
}
}
if (entries_per_aggregator > 0){
file_offsets_for_agg = (local_io_array *)
malloc(entries_per_aggregator*sizeof(local_io_array));
if (NULL == file_offsets_for_agg) {
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
sorted_file_offsets = (int *)
malloc (entries_per_aggregator*sizeof(int));
if (NULL == sorted_file_offsets){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
temp_index = 0;
for (i=0;i<fh->f_procs_per_group; i++){
for(j=0;j<disp_index[i];j++){
if (blocklen_per_process[i][j] > 0){
file_offsets_for_agg[temp_index].length =
blocklen_per_process[i][j];
file_offsets_for_agg[temp_index].process_id = i;
file_offsets_for_agg[temp_index].offset =
displs_per_process[i][j];
temp_index++;
}
}
}
}
else{
continue;
}
local_heap_sort (file_offsets_for_agg,
entries_per_aggregator,
sorted_file_offsets);
memory_displacements = (MPI_Aint *) malloc
(entries_per_aggregator * sizeof(MPI_Aint));
memory_displacements[sorted_file_offsets[0]] = 0;
for (i=1; i<entries_per_aggregator; i++){
memory_displacements[sorted_file_offsets[i]] =
memory_displacements[sorted_file_offsets[i-1]] +
file_offsets_for_agg[sorted_file_offsets[i-1]].length;
}
temp_disp_index = (int *)calloc (1, fh->f_procs_per_group * sizeof (int));
if (NULL == temp_disp_index) {
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
global_count = 0;
for (i=0;i<entries_per_aggregator;i++){
temp_pindex =
file_offsets_for_agg[sorted_file_offsets[i]].process_id;
displs_per_process[temp_pindex][temp_disp_index[temp_pindex]] =
memory_displacements[sorted_file_offsets[i]];
if (temp_disp_index[temp_pindex] < disp_index[temp_pindex])
temp_disp_index[temp_pindex] += 1;
else{
printf("temp_disp_index[%d]: %d is greater than disp_index[%d]: %d\n",
temp_pindex, temp_disp_index[temp_pindex],
temp_pindex, disp_index[temp_pindex]);
}
global_count +=
file_offsets_for_agg[sorted_file_offsets[i]].length;
}
if (NULL != temp_disp_index){
free(temp_disp_index);
temp_disp_index = NULL;
}
#if DEBUG_ON
printf("************Cycle: %d, Aggregator: %d ***************\n",
index+1,fh->f_rank);
for (i=0; i<entries_per_aggregator;i++){
printf("%d: OFFSET: %lld LENGTH: %ld, Mem-offset: %ld, disp : %d\n",
file_offsets_for_agg[sorted_file_offsets[i]].process_id,
file_offsets_for_agg[sorted_file_offsets[i]].offset,
file_offsets_for_agg[sorted_file_offsets[i]].length,
memory_displacements[sorted_file_offsets[i]],
disp_index[ file_offsets_for_agg[sorted_file_offsets[i]].process_id]);
}
#endif
#if DEBUG_ON
printf("%d: global_count : %ld, bytes_to_write_in_cycle : %ld, procs_per_group: %d\n",
fh->f_rank,
global_count,
bytes_to_write_in_cycle,
fh->f_procs_per_group);
#endif
#if OMPIO_FCOLL_WANT_TIME_BREAKDOWN
start_comm_time = MPI_Wtime();
#endif
global_buf = (char *) malloc (global_count);
if (NULL == global_buf){
opal_output(1, "OUT OF MEMORY");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
recv_req = (MPI_Request *)
malloc (fh->f_procs_per_group * sizeof(MPI_Request));
if (NULL == recv_req){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
for (i=0;i<fh->f_procs_per_group; i++){
ompi_datatype_create_hindexed(disp_index[i],
blocklen_per_process[i],
displs_per_process[i],
MPI_BYTE,
&recvtype[i]);
ompi_datatype_commit(&recvtype[i]);
ret = MCA_PML_CALL(irecv(global_buf,
1,
recvtype[i],
fh->f_procs_in_group[i],
123,
fh->f_comm,
&recv_req[i]));
if (OMPI_SUCCESS != ret){
fprintf(stderr,"irecv Error!\n");
goto exit;
}
}
}
if (fh->f_flags & OMPIO_CONTIGUOUS_MEMORY) {
send_buf = &((char*)buf)[total_bytes_written];
}
else if (bytes_to_write_in_cycle) {
/* allocate a send buffer and copy the data that needs
to be sent into it in case the data is non-contigous
in memory */
OPAL_PTRDIFF_TYPE mem_address;
size_t remaining = 0;
size_t temp_position = 0;
send_buf = malloc (bytes_to_write_in_cycle);
if (NULL == send_buf) {
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
remaining = bytes_to_write_in_cycle;
while (remaining) {
mem_address = (OPAL_PTRDIFF_TYPE)
(decoded_iov[iov_index].iov_base) + current_position;
if (remaining >=
(decoded_iov[iov_index].iov_len - current_position)) {
memcpy (send_buf+temp_position,
(IOVBASE_TYPE *)mem_address,
decoded_iov[iov_index].iov_len - current_position);
remaining = remaining -
(decoded_iov[iov_index].iov_len - current_position);
temp_position = temp_position +
(decoded_iov[iov_index].iov_len - current_position);
iov_index = iov_index + 1;
current_position = 0;
}
else {
memcpy (send_buf+temp_position,
(IOVBASE_TYPE *)mem_address,
remaining);
current_position = current_position + remaining;
remaining = 0;
}
}
}
total_bytes_written += bytes_to_write_in_cycle;
send_req = (MPI_Request *) malloc (sizeof(MPI_Request));
if (NULL == send_req){
opal_output (1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
ret = MCA_PML_CALL(isend(send_buf,
bytes_to_write_in_cycle,
MPI_BYTE,
fh->f_procs_in_group[fh->f_aggregator_index],
123,
MCA_PML_BASE_SEND_STANDARD,
fh->f_comm,
send_req));
if ( OMPI_SUCCESS != ret ){
fprintf(stderr,"isend error!\n");
goto exit;
}
ret = ompi_request_wait (send_req, MPI_STATUS_IGNORE);
if (OMPI_SUCCESS != ret){
goto exit;
}
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
ret = ompi_request_wait_all (fh->f_procs_per_group,
recv_req,
MPI_STATUS_IGNORE);
if (OMPI_SUCCESS != ret){
goto exit;
}
#if DEBUG_ON
printf("************Cycle: %d, Aggregator: %d ***************\n",
index+1,fh->f_rank);
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank){
for (i=0 ; i<global_count/4 ; i++)
printf (" RECV %d \n",((int *)global_buf)[i]);
}
#endif
}
#if OMPIO_FCOLL_WANT_TIME_BREAKDOWN
end_comm_time = MPI_Wtime();
comm_time += end_comm_time - start_comm_time;
#endif
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
fh->f_io_array = (mca_io_ompio_io_array_t *) malloc
(entries_per_aggregator * sizeof (mca_io_ompio_io_array_t));
if (NULL == fh->f_io_array) {
opal_output(1, "OUT OF MEMORY\n");
ret = OMPI_ERR_OUT_OF_RESOURCE;
goto exit;
}
fh->f_num_of_io_entries = 0;
/*First entry for every aggregator*/
fh->f_io_array[fh->f_num_of_io_entries].offset =
(IOVBASE_TYPE *)(intptr_t)file_offsets_for_agg[sorted_file_offsets[0]].offset;
fh->f_io_array[fh->f_num_of_io_entries].length =
file_offsets_for_agg[sorted_file_offsets[0]].length;
fh->f_io_array[fh->f_num_of_io_entries].memory_address =
global_buf+memory_displacements[sorted_file_offsets[0]];
fh->f_num_of_io_entries++;
for (i=1;i<entries_per_aggregator;i++){
if (file_offsets_for_agg[sorted_file_offsets[i-1]].offset +
file_offsets_for_agg[sorted_file_offsets[i-1]].length ==
file_offsets_for_agg[sorted_file_offsets[i]].offset){
fh->f_io_array[fh->f_num_of_io_entries - 1].length +=
file_offsets_for_agg[sorted_file_offsets[i]].length;
}
else {
fh->f_io_array[fh->f_num_of_io_entries].offset =
(IOVBASE_TYPE *)(intptr_t)file_offsets_for_agg[sorted_file_offsets[i]].offset;
fh->f_io_array[fh->f_num_of_io_entries].length =
file_offsets_for_agg[sorted_file_offsets[i]].length;
fh->f_io_array[fh->f_num_of_io_entries].memory_address =
global_buf+memory_displacements[sorted_file_offsets[i]];
fh->f_num_of_io_entries++;
}
}
#if DEBUG_ON
printf("*************************** %d\n", fh->f_num_of_io_entries);
for (i=0 ; i<fh->f_num_of_io_entries ; i++) {
printf(" ADDRESS: %p OFFSET: %ld LENGTH: %ld\n",
fh->f_io_array[i].memory_address,
(OPAL_PTRDIFF_TYPE)fh->f_io_array[i].offset,
fh->f_io_array[i].length);
}
#endif
#if OMPIO_FCOLL_WANT_TIME_BREAKDOWN
start_write_time = MPI_Wtime();
#endif
if (fh->f_num_of_io_entries) {
if ( 0 > fh->f_fbtl->fbtl_pwritev (fh)) {
opal_output (1, "WRITE FAILED\n");
ret = OMPI_ERROR;
goto exit;
}
}
#if OMPIO_FCOLL_WANT_TIME_BREAKDOWN
end_write_time = MPI_Wtime();
write_time += end_write_time - start_write_time;
#endif
}
if (NULL != send_req){
free(send_req);
send_req = NULL;
}
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
fh->f_num_of_io_entries = 0;
if (NULL != fh->f_io_array) {
free (fh->f_io_array);
fh->f_io_array = NULL;
}
for (i = 0; i < fh->f_procs_per_group; i++)
ompi_datatype_destroy(recvtype+i);
if (NULL != recvtype){
free(recvtype);
recvtype=NULL;
}
if (NULL != recv_req){
free(recv_req);
recv_req = NULL;
}
if (NULL != global_buf) {
free (global_buf);
global_buf = NULL;
}
}
}
#if OMPIO_FCOLL_WANT_TIME_BREAKDOWN
end_exch = MPI_Wtime();
exch_write += end_exch - start_exch;
nentry.time[0] = write_time;
nentry.time[1] = comm_time;
nentry.time[2] = exch_write;
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank)
nentry.aggregator = 1;
else
nentry.aggregator = 0;
nentry.nprocs_for_coll = static_num_io_procs;
if (!fh->f_full_print_queue(WRITE_PRINT_QUEUE)){
fh->f_register_print_entry(WRITE_PRINT_QUEUE,
nentry);
}
#endif
exit:
if (NULL != decoded_iov){
free(decoded_iov);
decoded_iov = NULL;
}
if (fh->f_procs_in_group[fh->f_aggregator_index] == fh->f_rank) {
if (NULL != local_iov_array){
free(local_iov_array);
local_iov_array = NULL;
}
for(l=0;l<fh->f_procs_per_group;l++){
if (NULL != blocklen_per_process[l]){
free(blocklen_per_process[l]);
blocklen_per_process[l] = NULL;
}
if (NULL != displs_per_process[l]){
free(displs_per_process[l]);
displs_per_process[l] = NULL;
}
}
}
if (NULL != send_buf){
free(send_buf);
send_buf = NULL;
}
if (NULL != global_buf){
free(global_buf);
global_buf = NULL;
}
if (NULL != recvtype){
free(recvtype);
recvtype = NULL;
}
if (NULL != sorted_file_offsets){
free(sorted_file_offsets);
sorted_file_offsets = NULL;
}
if (NULL != file_offsets_for_agg){
free(file_offsets_for_agg);
file_offsets_for_agg = NULL;
}
if (NULL != memory_displacements){
free(memory_displacements);
memory_displacements = NULL;
}
if (NULL != displs_per_process){
free(displs_per_process);
displs_per_process = NULL;
}
if (NULL != blocklen_per_process){
free(blocklen_per_process);
blocklen_per_process = NULL;
}
if(NULL != current_index){
free(current_index);
current_index = NULL;
}
if(NULL != bytes_remaining){
free(bytes_remaining);
bytes_remaining = NULL;
}
if (NULL != disp_index){
free(disp_index);
disp_index = NULL;
}
if (NULL != sorted) {
free(sorted);
sorted = NULL;
}
return ret;
}
