/**
* This is a function, which allocates a block with necessary @size.
*
* @size - size of needed block;
* @return - pointer to the allocated memory; */
static void *memory_allocate(size_t req_size) {
/* allocated part */
struct block_desc *new_block;
/* another part of existing block */
struct block_desc *old_block;
/*If suit block is not exist, allocation is impossible*/
if (NULL == (new_block = find_suit_block(req_size))) {
return NULL;
}
/* Change state flag on unavailable*/
set_not_available(new_block);
/*If old block less then BLOCK_DESC_SIZE don't to cut it*/
if ((new_block->size - req_size - BLOCK_DESC_SIZE) >= BLOCK_DESC_SIZE) {
/* Initializes a new block on the remaining part of block */
old_block = (void *) ((size_t) new_block + req_size + BLOCK_DESC_SIZE);
set_available(old_block);
old_block->size = new_block->size - req_size - BLOCK_DESC_SIZE;
/* Fixed req_size of block */
new_block->size = req_size + BLOCK_DESC_SIZE;
}
/*If select min free space, change enter to search */
if (current_space == (void*) new_block) {
current_space += (uint32_t) (new_block->size); /* check types*/
}
printf("returned 0x%x\n",
(uint32_t) (new_block) + (uint32_t) (BLOCK_DESC_SIZE));
printf("current_free_space 0x%x\n", (uint32_t) current_space);
/*Return point to memory in block*/
return (void *) ((uint32_t) (new_block) + (uint32_t) (BLOCK_DESC_SIZE));
}
LNE_NAMESPACE_USING
ThreadMutex::ThreadMutex(void)
{
#if defined(LNE_WIN32)
mutex_ = CreateMutex(NULL, FALSE, NULL);
set_available(mutex_ != NULL);
#else
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
pthread_mutex_init(&mutex_, &attr);
pthread_mutexattr_destroy(&attr);
set_available(true);
#endif
}
void TicTac_Button::handle(event ev)
{
if(!status && available)
{
if(turn) status=2;
else status=1;
set_available();
}
}
// Preallocate the maximum number of operations that can be enqueued.
int Win32AttachListener::init() {
_mutex = (void*)::CreateMutex(NULL, FALSE, NULL);
guarantee(_mutex != (HANDLE)NULL, "mutex creation failed");
_enqueued_ops_semaphore = ::CreateSemaphore(NULL, 0, max_enqueued_operations, NULL);
guarantee(_enqueued_ops_semaphore != (HANDLE)NULL, "semaphore creation failed");
set_head(NULL);
set_tail(NULL);
set_available(NULL);
for (int i=0; i<max_enqueued_operations; i++) {
Win32AttachOperation* op = new Win32AttachOperation();
op->set_next(available());
set_available(op);
}
return 0;
}
// preallocate the required number of operations
int Win32AttachListener::init() {
_mutex = (void*)::CreateMutex(NULL, FALSE, NULL);
guarantee(_mutex != (HANDLE)NULL, "mutex creation failed");
_wakeup = ::CreateSemaphore(NULL, 0, 1, NULL);
guarantee(_wakeup != (HANDLE)NULL, "semaphore creation failed");
set_head(NULL);
set_tail(NULL);
// preallocate a few operations
set_available(NULL);
for (int i=0; i<preallocate_count; i++) {
Win32AttachOperation* op = new Win32AttachOperation();
op->set_next(available());
set_available(op);
}
return 0;
}
// Enqueue an operation. This is called from a native thread that is not attached to VM.
// Also we need to be careful not to execute anything that results in more than a 4k stack.
//
int Win32AttachListener::enqueue(char* cmd, char* arg0, char* arg1, char* arg2, char* pipename) {
// listener not running
if (!AttachListener::is_initialized()) {
return ATTACH_ERROR_DISABLED;
}
// check that all paramteres to the operation
if (strlen(cmd) > AttachOperation::name_length_max) return ATTACH_ERROR_ILLEGALARG;
if (strlen(arg0) > AttachOperation::arg_length_max) return ATTACH_ERROR_ILLEGALARG;
if (strlen(arg1) > AttachOperation::arg_length_max) return ATTACH_ERROR_ILLEGALARG;
if (strlen(arg2) > AttachOperation::arg_length_max) return ATTACH_ERROR_ILLEGALARG;
if (strlen(pipename) > Win32AttachOperation::pipe_name_max) return ATTACH_ERROR_ILLEGALARG;
// check for a well-formed pipename
if (strstr(pipename, "\\\\.\\pipe\\") != pipename) return ATTACH_ERROR_ILLEGALARG;
// grab the lock for the list
DWORD res = ::WaitForSingleObject(mutex(), INFINITE);
if (res != WAIT_OBJECT_0) {
return ATTACH_ERROR_INTERNAL;
}
// try to get an operation from the available list
Win32AttachOperation* op = available();
if (op != NULL) {
set_available(op->next());
// add to end (tail) of list
op->set_next(NULL);
if (tail() == NULL) {
set_head(op);
} else {
tail()->set_next(op);
}
set_tail(op);
op->set_name(cmd);
op->set_arg(0, arg0);
op->set_arg(1, arg1);
op->set_arg(2, arg2);
op->set_pipe(pipename);
// Increment number of enqueued operations.
// Side effect: Semaphore will be signaled and will release
// any blocking waiters (i.e. the AttachListener thread).
BOOL not_exceeding_semaphore_maximum_count =
::ReleaseSemaphore(enqueued_ops_semaphore(), 1, NULL);
guarantee(not_exceeding_semaphore_maximum_count, "invariant");
}
::ReleaseMutex(mutex());
return (op != NULL) ? 0 : ATTACH_ERROR_RESOURCE;
}
// Enqueue an operation. This is called from a native thread that is not attached to VM.
// Also we need to be careful not to execute anything that results in more than a 4k stack.
//
int Win32AttachListener::enqueue(char* cmd, char* arg0, char* arg1, char* arg2, char* pipename) {
// listener not running
if (!AttachListener::is_initialized()) {
return ATTACH_ERROR_DISABLED;
}
// check that all paramteres to the operation
if (strlen(cmd) > AttachOperation::name_length_max) return ATTACH_ERROR_ILLEGALARG;
if (strlen(arg0) > AttachOperation::arg_length_max) return ATTACH_ERROR_ILLEGALARG;
if (strlen(arg0) > AttachOperation::arg_length_max) return ATTACH_ERROR_ILLEGALARG;
if (strlen(pipename) > Win32AttachOperation::pipe_name_max) return ATTACH_ERROR_ILLEGALARG;
// check for a well-formed pipename
if (strstr(pipename, "\\\\.\\pipe\\") != pipename) return ATTACH_ERROR_ILLEGALARG;
// grab the lock for the list
DWORD res = ::WaitForSingleObject(mutex(), INFINITE);
if (res != WAIT_OBJECT_0) {
return ATTACH_ERROR_INTERNAL;
}
// try to get an operation from the available list
Win32AttachOperation* op = available();
if (op != NULL) {
set_available(op->next());
// add to end (tail) of list
op->set_next(NULL);
if (tail() == NULL) {
set_head(op);
} else {
tail()->set_next(op);
}
set_tail(op);
op->set_name(cmd);
op->set_arg(0, arg0);
op->set_arg(1, arg1);
op->set_arg(2, arg2);
op->set_pipe(pipename);
// wakeup the thread waiting for operations
::ReleaseSemaphore(wakeup(), 1, NULL);
}
::ReleaseMutex(mutex());
return (op != NULL) ? 0 : ATTACH_ERROR_RESOURCE;
}
/* This procedure makes free busy block
* at the specified @address.
* @address - block address being freed; */
static void memory_free(void *address) {
/* Detect address of memory_block */
struct block_desc *md = address - BLOCK_DESC_SIZE;
/* Make block free*/
set_available(md);
/* Set the new value of pointer to the free block */
if (current_space > (char *) md) {
current_space = (char *) md;
} else {
md = (void *) current_space;
}
/*Resolve defragmentation*/
defragmentation(md);
printf("NEW current_free_space 0x%x\n", (uint32_t) current_space);
}
int
main(int argc, char *argv[]) {
int x, y;
prog = argv[0];
load_config("menu");
init_font_locale(lookup("locale", 0, 0));
set_screen_size(SCREEN_WIDTH, SCREEN_HEIGHT);
layout_screen();
init_display(argc, argv, prog);
ARGBEGIN {
case 'd': debug++; break;
default:
return usage();
} ARGEND;
set_available(argv);
io_main_loop();
return 0;
}
int main()
{
struct timeval start, end;
int running = 1;
void *shared_memory = (void *)0;
struct shared_use_st *shared_stuff;
int shmid;
srand((unsigned int)getpid());
sem_id = semget((key_t)1233, 1, 0666 | IPC_CREAT);
sem_id2 = semget((key_t)1235, 1, 0666 | IPC_CREAT);
sem_id3 = semget((key_t)1236, 1, 0666 | IPC_CREAT);
if (!set_available()| !set_empty()) {
fprintf(stderr, "Failed to initialize semaphore\n");
exit(EXIT_FAILURE);
}
shmid = shmget((key_t)1231, (sizeof(struct shared_use_st)- sizeof(int)) , 0666 | IPC_CREAT);
if (shmid == -1) {
fprintf(stderr, "shmget failed prod\n");
exit(EXIT_FAILURE);
}
/* We now make the shared memory accessible to the program. */
shared_memory = shmat(shmid, (void *)0, 0);
if (shared_memory == (void *)-1) {
fprintf(stderr, "shmat failed\n");
exit(EXIT_FAILURE);
}
printf("Memory attached at %X\n", (void *)shared_memory);
/* The next portion of the program assigns the shared_memory segment to shared_stuff,
which then prints out any text in written_by_you. The loop continues until end is found
in written_by_you. The call to sleep forces the consumer to sit in its critical section,
which makes the producer wait. */
shared_stuff = (struct shared_use_st *)shared_memory;
//shared_stuff->written_by_you = 0;
char ibuffer[BUFSIZ]; // input buffer
int in; // variable to hold reference to input file
int index=0; // current index of element in array of structs in shared memory
int len; // length read
int tot = 0; // Total length read
//timer start
gettimeofday(&start, NULL);
for (int i = 0; i < 100000; i++){}
in = open("test4k.txt",O_RDONLY);
len = read(in,ibuffer, sizeof(ibuffer));
while(running){
for(int i = 0; i<= len; i+=128){
//sleep(2);
if((len-i)<128){
shared_stuff->msgs[index].written = len-i;
memcpy(shared_stuff->msgs[index].some_text, ibuffer + (len-i), (len-i));
tot+= shared_stuff->msgs[index].written;
printf("Producer: bytes written val %d\n", shared_stuff->msgs[index].written);
printf("Producer: Total bytes written val %d\n", tot);
//timer finished
gettimeofday(&end, NULL);
printf("\nElapsed Time: %ld micro sec\n", ((end.tv_sec * MICRO_SEC_IN_SEC + end.tv_usec)- (start.tv_sec * MICRO_SEC_IN_SEC + start.tv_usec)));
sleep(4);
del_semvalue();
/*
//timer finished
gettimeofday(&end, NULL);
printf("\nElapsed Time: %ld micro sec\n", ((end.tv_sec * MICRO_SEC_IN_SEC + end.tv_usec)- (start.tv_sec * MICRO_SEC_IN_SEC + start.tv_usec)));
*/
exit(EXIT_SUCCESS);
}
else{
empty_p();
shared_stuff->msgs[index].written = 128;
//printf("writte\n");
printf("Producer: bytes written val %d\n", shared_stuff->msgs[index].written);
memcpy(shared_stuff->msgs[index].some_text,ibuffer + i,128);
tot+= shared_stuff->msgs[index].written;
index = (index+1)%k;
available_v();
}
}
}
/* Lastly, the shared memory is detached and then deleted. */
if (shmdt(shared_memory) == -1) {
fprintf(stderr, "shmdt failed\n");
exit(EXIT_FAILURE);
}
if (shmctl(shmid, IPC_RMID, 0) == -1) {
fprintf(stderr, "shmctl(IPC_RMID) failed\n");
exit(EXIT_FAILURE);
}
//del_semvalue();
exit(EXIT_SUCCESS);
}
int main()
{
int running = 1;
void *shared_memory = (void *)0;
struct shared_use_st *shared_stuff;
int shmid;
srand((unsigned int)getpid());
//get the semaphores
sem_id = semget((key_t)1233, 1, 0666 | IPC_CREAT);
sem_id2 = semget((key_t)1235, 1, 0666 | IPC_CREAT);
sem_id3 = semget((key_t)1236, 1, 0666 | IPC_CREAT);
/*
*sets the semaphores to the required values if it fails program ends
*/
if (!set_mutex()| !set_available()| !set_empty()) {
fprintf(stderr, "Failed to initialize semaphore\n");
exit(EXIT_FAILURE);
}
//get shared memory
shmid = shmget((key_t)1231, (sizeof(struct shared_use_st)- sizeof(int)) , 0666 | IPC_CREAT);
if (shmid == -1) {
fprintf(stderr, "shmget failed prod\n");
exit(EXIT_FAILURE);
}
/* We now make the shared memory accessible to the program. */
shared_memory = shmat(shmid, (void *)0, 0);
if (shared_memory == (void *)-1) {
fprintf(stderr, "shmat failed\n");
exit(EXIT_FAILURE);
}
printf("Memory attached at %X\n", (void *)shared_memory);
/* The next portion of the program assigns the shared_memory segment to shared_stuff,
Reads in from the input file test4k.txt into the buffer ibuffer string of size BUFSIZ, then the
loop continually copies text from ibuffer into the buffers in shared memory which take 128 bytes of char until a value less than 128 is written which means approached end of text then it sleeps and deletes the semaphores */
shared_stuff = (struct shared_use_st *)shared_memory;
//shared_stuff->written_by_you = 0;
char ibuffer[BUFSIZ]; // input buffer
int in; // variable to hold reference to input file
int index=0; // current index of element in array of structs in shared memory
int len; // length read
int tot = 0; // Total length read
in = open("test4k.txt",O_RDONLY);
len = read(in,ibuffer, sizeof(ibuffer));
while(running){
for(int i = 0; i<= len; i+=128){
sleep(2);
if((len-i)<128){
//if value written is less than 128 delete semaphores
shared_stuff->msgs[index].written = len-i;
memcpy(shared_stuff->msgs[index].some_text, ibuffer + (len-i), (len-i));
tot+= shared_stuff->msgs[index].written;
printf("Producer: bytes written val %d\n", shared_stuff->msgs[index].written);
printf("Producer: Total bytes written val %d\n", tot);
sleep(10);
del_semvalue();
exit(EXIT_SUCCESS);
}
else{
empty_p();
mutex_p();
shared_stuff->msgs[index].written = 128;
printf("Producer: bytes written val %d\n", shared_stuff->msgs[index].written);
memcpy(shared_stuff->msgs[index].some_text,ibuffer + i,128);
tot+= shared_stuff->msgs[index].written;
index = (index+1)%k;
mutex_v();
available_v();
}
}
}
/* Lastly, the shared memory is detached and then deleted. */
if (shmdt(shared_memory) == -1) {
fprintf(stderr, "shmdt failed\n");
exit(EXIT_FAILURE);
}
if (shmctl(shmid, IPC_RMID, 0) == -1) {
fprintf(stderr, "shmctl(IPC_RMID) failed\n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
