static void
copy_hfa_to_reg_or_stack (void *memory,
ffi_type *ty,
struct call_context *context,
unsigned char *stack,
struct arg_state *state)
{
unsigned elems = element_count (ty);
if (available_v (state) < elems)
{
/* There are insufficient V registers. Further V register allocations
are prevented, the NSAA is adjusted (by allocate_to_stack ())
and the argument is copied to memory at the adjusted NSAA. */
state->nsrn = N_V_ARG_REG;
memcpy (allocate_to_stack (state, stack, ty->alignment, ty->size),
memory,
ty->size);
}
else
{
int i;
unsigned short type = get_homogeneous_type (ty);
for (i = 0; i < elems; i++)
{
void *reg = allocate_to_v (context, state);
copy_basic_type (reg, memory, type);
memory += get_basic_type_size (type);
}
}
}
void FFI_HIDDEN
ffi_closure_SYSV_inner (ffi_closure *closure, struct call_context *context,
void *stack)
{
ffi_cif *cif = closure->cif;
void **avalue = (void**) alloca (cif->nargs * sizeof (void*));
void *rvalue = NULL;
int i;
struct arg_state state;
arg_init (&state, ALIGN(cif->bytes, 16));
for (i = 0; i < cif->nargs; i++)
{
ffi_type *ty = cif->arg_types[i];
switch (ty->type)
{
case FFI_TYPE_VOID:
FFI_ASSERT (0);
break;
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT16:
case FFI_TYPE_SINT16:
case FFI_TYPE_UINT32:
case FFI_TYPE_SINT32:
case FFI_TYPE_INT:
case FFI_TYPE_POINTER:
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
avalue[i] = allocate_to_register_or_stack (context, stack,
&state, ty->type);
break;
#endif
case FFI_TYPE_STRUCT:
if (is_hfa (ty))
{
unsigned n = element_count (ty);
if (available_v (&state) < n)
{
state.nsrn = N_V_ARG_REG;
avalue[i] = allocate_to_stack (&state, stack, ty->alignment,
ty->size);
}
else
{
switch (get_homogeneous_type (ty))
{
case FFI_TYPE_FLOAT:
{
/* Eeek! We need a pointer to the structure,
however the homogeneous float elements are
being passed in individual S registers,
therefore the structure is not represented as
a contiguous sequence of bytes in our saved
register context. We need to fake up a copy
of the structure laid out in memory
correctly. The fake can be tossed once the
closure function has returned hence alloca()
is sufficient. */
int j;
UINT32 *p = avalue[i] = alloca (ty->size);
for (j = 0; j < element_count (ty); j++)
memcpy (&p[j],
allocate_to_s (context, &state),
sizeof (*p));
break;
}
case FFI_TYPE_DOUBLE:
{
/* Eeek! We need a pointer to the structure,
however the homogeneous float elements are
being passed in individual S registers,
therefore the structure is not represented as
a contiguous sequence of bytes in our saved
register context. We need to fake up a copy
of the structure laid out in memory
correctly. The fake can be tossed once the
closure function has returned hence alloca()
is sufficient. */
int j;
UINT64 *p = avalue[i] = alloca (ty->size);
for (j = 0; j < element_count (ty); j++)
memcpy (&p[j],
allocate_to_d (context, &state),
sizeof (*p));
break;
}
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
memcpy (&avalue[i],
allocate_to_v (context, &state),
sizeof (*avalue));
break;
#endif
default:
FFI_ASSERT (0);
break;
}
}
}
else if (ty->size > 16)
{
/* Replace Composite type of size greater than 16 with a
pointer. */
memcpy (&avalue[i],
allocate_to_register_or_stack (context, stack,
&state, FFI_TYPE_POINTER),
sizeof (avalue[i]));
}
else if (available_x (&state) >= (ty->size + 7) / 8)
{
avalue[i] = get_x_addr (context, state.ngrn);
state.ngrn += (ty->size + 7) / 8;
}
else
{
state.ngrn = N_X_ARG_REG;
avalue[i] = allocate_to_stack (&state, stack, ty->alignment,
ty->size);
}
break;
default:
FFI_ASSERT (0);
break;
}
}
/* Figure out where the return value will be passed, either in
registers or in a memory block allocated by the caller and passed
in x8. */
if (is_register_candidate (cif->rtype))
{
/* Register candidates are *always* returned in registers. */
/* Allocate a scratchpad for the return value, we will let the
callee scrible the result into the scratch pad then move the
contents into the appropriate return value location for the
call convention. */
rvalue = alloca (cif->rtype->size);
(closure->fun) (cif, rvalue, avalue, closure->user_data);
/* Copy the return value into the call context so that it is returned
as expected to our caller. */
switch (cif->rtype->type)
{
case FFI_TYPE_VOID:
break;
case FFI_TYPE_UINT8:
case FFI_TYPE_UINT16:
case FFI_TYPE_UINT32:
case FFI_TYPE_POINTER:
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT8:
case FFI_TYPE_SINT16:
case FFI_TYPE_INT:
case FFI_TYPE_SINT32:
case FFI_TYPE_SINT64:
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
#endif
{
void *addr = get_basic_type_addr (cif->rtype->type, context, 0);
copy_basic_type (addr, rvalue, cif->rtype->type);
break;
}
case FFI_TYPE_STRUCT:
if (is_hfa (cif->rtype))
{
int j;
unsigned short type = get_homogeneous_type (cif->rtype);
unsigned elems = element_count (cif->rtype);
for (j = 0; j < elems; j++)
{
void *reg = get_basic_type_addr (type, context, j);
copy_basic_type (reg, rvalue, type);
rvalue += get_basic_type_size (type);
}
}
else if ((cif->rtype->size + 7) / 8 < N_X_ARG_REG)
{
size_t size = ALIGN (cif->rtype->size, sizeof (UINT64)) ;
memcpy (get_x_addr (context, 0), rvalue, size);
}
else
{
FFI_ASSERT (0);
}
break;
default:
FFI_ASSERT (0);
break;
}
}
else
{
memcpy (&rvalue, get_x_addr (context, 8), sizeof (UINT64));
(closure->fun) (cif, rvalue, avalue, closure->user_data);
}
}
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);
}
