static gboolean i3ipc_connection_initable_init(GInitable *initable, GCancellable *cancellable, GError **err) { i3ipcConnection *self = I3IPC_CONNECTION(initable); GError *tmp_error = NULL; g_return_val_if_fail(err == NULL || *err == NULL, FALSE); self->priv->socket_path = i3ipc_connection_get_socket_path(self, &tmp_error); if (tmp_error != NULL) { g_propagate_error(err, tmp_error); return FALSE; } int cmd_fd = get_file_descriptor(self->priv->socket_path, &tmp_error); if (tmp_error != NULL) { g_propagate_error(err, tmp_error); return FALSE; } self->priv->cmd_channel = g_io_channel_unix_new(cmd_fd); int sub_fd = get_file_descriptor(self->priv->socket_path, &tmp_error); if (tmp_error != NULL) { g_propagate_error(err, tmp_error); return FALSE; } self->priv->sub_channel = g_io_channel_unix_new(sub_fd); g_io_channel_set_encoding(self->priv->cmd_channel, NULL, &tmp_error); if (tmp_error != NULL) { g_propagate_error(err, tmp_error); return FALSE; } g_io_channel_set_encoding(self->priv->sub_channel, NULL, &tmp_error); if (tmp_error != NULL) { g_propagate_error(err, tmp_error); return FALSE; } g_io_add_watch(self->priv->sub_channel, G_IO_IN, (GIOFunc)ipc_on_data, self); self->priv->connected = TRUE; return TRUE; }
static void simread(const char *const *action) { const char *processid = action[0]; const char *file_name = action[2]; const char *index = action[4]; const char *position_str =action[5]; const char *size_str = action[6]; msg_file_t file = NULL; sg_size_t size = parse_size(size_str); sg_offset_t position= parse_offset(position_str); double clock = MSG_get_clock(); /* this "call" is free thanks to inlining */ if(position<2880 && (position+size)<2880) { file = get_file_descriptor("fast",file_name,index); ACT_DEBUG("Entering Read: %s (size: %llu)", NAME, size); MSG_file_seek(file,position,SEEK_SET); MSG_file_read(file, size); } else if(position<2880 && (position+size)>2880) { //read the Head part file = get_file_descriptor("fast",file_name,index); ACT_DEBUG("Entering Read: %s (size: %llu)", NAME, size); MSG_file_seek(file,position,SEEK_SET); MSG_file_read(file, (2880-position)); //read the data part file = get_file_descriptor("slow",file_name,index); ACT_DEBUG("Entering Read: %s (size: %llu)", NAME, size); MSG_file_seek(file,2880,SEEK_SET); MSG_file_read(file, size-(2880-position)); } else { XBT_INFO("3 position is %llu ,size is %llu",position,size); file = get_file_descriptor("slow",file_name,index); ACT_DEBUG("Entering Read: %s (size: %llu)", NAME, size); MSG_file_seek(file,position,SEEK_SET); MSG_file_read(file, size); } log_action(action, MSG_get_clock() - clock); XBT_INFO("read worker %s%s is done",processid,index); }
static void action_close(const char *const *action) { const char *file_name = action[2]; msg_file_t file; double clock = MSG_get_clock(); file = get_file_descriptor(file_name); ACT_DEBUG("Entering Close: %s (filename: %s)", NAME, file_name); MSG_file_close(file); log_action(action, MSG_get_clock() - clock); }
static void simrelease(const char *const *action) { const char *processid = action[0]; const char *file_name = action[2]; const char *index = action[4]; msg_file_t file; double clock = MSG_get_clock(); /* this "call" is free thanks to inlining */ file = get_file_descriptor(file_name,index); ACT_DEBUG("Entering Close: %s (filename: %s)", NAME, file_name); MSG_file_close(file); log_action(action, MSG_get_clock() - clock); XBT_INFO("release worker %s%s is done",processid,index); }
static void simrelease(const char *const *action) { const char *processid = action[0]; const char *file_name = action[2]; const char *worktime = action[3]; double sleeptime; const char *index = action[4]; msg_file_t file; double clock = MSG_get_clock(); /* this "call" is free thanks to inlining */ //Because the action release is too fast ,to catch up with the clock of the simulator, we let it to sleep for a while. sleeptime = atof(worktime); MSG_process_sleep(sleeptime); //close slow file file = get_file_descriptor("slow",file_name,index); ACT_DEBUG("Entering Close: %s (filename: %s)", NAME, file_name); MSG_file_close(file); //close fast file file = get_file_descriptor("fast",file_name,index); ACT_DEBUG("Entering Close: %s (filename: %s)", NAME, file_name); MSG_file_close(file); log_action(action, MSG_get_clock() - clock); XBT_INFO("release worker %s%s is done",processid,index); }
static void action_read(const char *const *action) { const char *file_name = action[2]; const char *size_str = action[3]; msg_file_t file = NULL; sg_size_t size = parse_size(size_str); double clock = MSG_get_clock(); file = get_file_descriptor(file_name); ACT_DEBUG("Entering Read: %s (size: %llu)", NAME, size); MSG_file_read(file, size); log_action(action, MSG_get_clock() - clock); }
ProtoFrameInputStream::ProtoFrameInputStream(const char* path) : FrameInputStream() { m_file = fopen(path, "rb"); if (m_file == nullptr) { throw ResourceNotFoundException(path); } m_fileDescriptor = get_file_descriptor(m_file); m_fileSize = get_file_size(m_fileDescriptor); m_inputStream = astra::make_unique<FileInputStream>(m_fileDescriptor); }
static void simread(const char *const *action) { const char *processid = action[0]; const char *file_name = action[2]; const char *index = action[4]; const char *position_str =action[5]; const char *size_str = action[6]; msg_file_t file = NULL; sg_size_t size = parse_size(size_str); sg_offset_t position= parse_offset(position_str); double clock = MSG_get_clock(); /* this "call" is free thanks to inlining */ file = get_file_descriptor(file_name,index); ACT_DEBUG("Entering Read: %s (size: %llu)", NAME, size); MSG_file_seek(file,position,SEEK_SET); MSG_file_read(file, size); log_action(action, MSG_get_clock() - clock); XBT_INFO("read worker %s%s is done",processid,index); }
mapid_t mmap(int fd, void *addr) { struct thread *curr = thread_current(); int i; if (addr == 0) { return -1; } // Check validity of fd if (fd == 0 || fd == 1) { return -1; } struct file_desc *d = get_file_descriptor(fd); if (d && d->file) { int flength = file_length(d->file); if (flength == 0) { return -1; } int num_pages = flength / PGSIZE + 1; if ((int) addr & (PGSIZE - 1) != 0) { return -1; } void *curr_addr = addr; for (i = 0; i < num_pages; i++) { if (pagedir_get_page(curr->pagedir, curr_addr) != NULL) { return -1; } } // We should be ready to actually map at this point. struct mapped_file *ms = palloc_get_page(0); ms->page = addr; ms->length = num_pages; if (list_empty(&(thread_current()->mapped_files))) { ms->id = 0; } else { ms->id = list_entry(list_back(&(thread_current()->mapped_files)), struct mapped_file, elem)->id + 1; } curr_addr = addr; int offset = 0; // Alter the SPT, add entries for each page for (i = 0; i < num_pages; i++) { if (flength >= PGSIZE) { vm_install_mmap_spte(curr_addr, d->file, offset, PGSIZE, 0, true); } else { vm_install_mmap_spte(curr_addr, d->file, offset, flength, PGSIZE - flength, true); } curr_addr += PGSIZE; offset += PGSIZE; } list_push_back(&(thread_current()->mapped_files), &(ms->elem)); return ms->id; }
int main(int argc, char *argv[]) { // The memory region to which the file will be mapped void *file_memory; // The file descriptor of the file we will // map into our process's memory int file_descriptor; // Fetch command-line arguments struct Arguments args; parse_arguments(&args, argc, argv); file_descriptor = get_file_descriptor(args.size); /* Arguments: 1: Where to map the file to in the process' address space; NULL = let the OS find a region 2: The size of the file in bytes 3: The access rights, a bitwise OR of: PROT_READ, PROT_WRITE and PROT_EXEC 4: Flags for the mapped memory, a bitwise OR of: * MAP_FIXED: don't take the first argument as a hint, but really map the file there; you must ensure page-alignment, * MAP_PRIVATE: make a copy of the file if a write occurs, i.e. the actual file will never change, only the *local* copy, * MAP_SHARED: flush modified data to the underlying file immediately, instead of buffering; necessary for IPC!. Without MAP_SHARED, writes may be buffered by the OS. * MAP_FILE: the default (zero) flag. 5: The file descriptor to the opened file. 6: The offset from the beginnning in the file, starting from which to map. */ // clang-format off file_memory = mmap( NULL, 1 + args.size, PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0 ); // clang-format on if (file_memory < 0) { throw("Error mapping file!"); } /* If you do not specify MAP_SHARED, but just MAP_FILE (the default), writes may be buffered by the OS. You can then flush the memory manually by calling msync(memory_address, memory_length, flags), where flags is the combination of: * MS_SYNC: Flush immediately, blocking until it's done. * MS_ASYNC: Schedule a flush, but the buffer may not necessarily have been flushed before the call to msync returns. * MS_INVALIDATE: Invalidate all other process' cached data, so the change will be visible to them. Usually one would use: MS_SYNC | MS_INVALIDATE, so: msync(file_memory, FILE_SIZE, MS_SYNC | MS_INVALIDATE); */ // Don't need the file descriptor anymore at this point if (close(file_descriptor) < 0) { throw("Error closing file!"); } communicate(file_memory, &args); // Unmap the file from the process memory // Actually unncessary because the OS will do // this automatically when the process terminates if (munmap(file_memory, args.size) < 0) { throw("Error unmapping file!"); } close(file_descriptor); return EXIT_SUCCESS; }