#include<stdio.h>
#include<pthread.h>
struct array_with_length
{       int length;
        int *array;
};
pthread_t sa[16];

void* matrix_mult(void *arguments)
{       int i,arg_length;
        pthread_t myid=pthread_self();
        for(i=0;i<16;i++)
                if(pthread_equal(myid,sa[i]))
                {       //printf("\npthread[%d] speaking",i);
                        break;
                }
        if(arguments==NULL)
                printf("\npthread[%d] speaking .Got not work",i);
        else
        {       arg_length=((struct array_with_length*)arguments)->length;
                printf("\npthread[%d] speaking . Got a matrix of size %d\nNamely: ",i,arg_length);
                for(i=0;i<arg_length;i++)
                        printf("%d\t",((struct array_with_length*)arguments)->array[i]);
                printf("\n");
        }
        return NULL;
}
int main()
{       int i,j,err_on_pthread_creation;
        struct array_with_length awl;
        int source_array[4][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
        awl.length=16;
        awl.array=source_array;
        printf("\nour mesh will be :\n");
        for(i=0;i<4;i++)
        {       printf("\n");
                for(j=0;j<4;j++)
                        printf("\t%d",source_array[i][j]);
        }
        for(i=0;i<16;i++)
        {       if(i==0)
        {       if(i==0)
                        err_on_pthread_creation=pthread_create(&sa[i],NULL,&matrix_mult,&awl);
                else
                        err_on_pthread_creation=pthread_create(&sa[i],NULL,&matrix_mult,NULL);
                if(err_on_pthread_creation!=0)
                        printf("\nError while creating pthread[%d]",i);
                else
                        printf("\npthread[%d] created",i);
        }
        printf("\n\n");
        sleep(10);
        return 0;
}

/******* below are the two data structures I use for inter-thread communication ***********
** actually, there is a global array but each element of the array serves as a mailbox*****
*** as the model goes. A consumer takes delivery of a package, a pointer in an array of****
*** pointers to struct thread_mailbox_package,  *******************************************
**** it depends on threads behaving and not accessing one another's mailboxes**************
** The producer makes up the package and sets the flag indicating it's ready for pickup****
** That's the message-passing -it's not synchronized. the consumer does its thing until****
** it's ready for a new package, the producer waits for a new order after it's delivered **
** it works very very well for me****/

/**this is the struct, which is typedef'd here, which has the flags and pointers to data **/

typedef struct thread_mailbox_package {

	int 			package_ready_for_pickup_flag;
	int 			package_order_flag;

	LGobject_t 		*package_being_delivered;
	LGobject_t 		*package_currently_used;

	struct object_data	*package_contents;

} thread_mailbox_package_type;


/*this is an array of pointers to the 'mailboxes' ---each thread has a number, it's index *
** into the array, for it's particular 'mailbox'*** these threads control sprites, btw****/

thread_mailbox_package_type	*sprite_threads[number_of_threads];


/*****here is the function called through pthread_create or lthread_create. If using lthread_create ********
***** the declaration wouldbe: void sprite_packaging_thread( etc.) *****************************************
*/

void* sprite_packaging_thread(void *data){

	(sprite_thread_data *)this_thread = data;

	/*****initialization, then enter a continuous loop, where it accepts data from another producer ********
	**** is delivered by another thread, which provides data for this thread's ongoing calculations ********

	for( ; ; ){

	/*thread-specific code including accepting packages of data    ***** 
	*			.
	*			.
	*			etc.,
	/** code which puts together this_thread's particular data. the thread does some calculating and*******
	** then sets the flag for pickup by consumer thread, in this case a 'mailman' that delivers data ******
	** to another consumer, and also draws on the screen with it ********
				 .
				etc.,
	/****here's how the package  from this thread is made available--by setting the flag, in the struct ***
	**  pointer, this_thread->package_ready_for_pickup  to yes. Afterward, it polls the consumer's flag ***
	**  this_thread_->package_order_flag, set to yes when the consumer is ready for another package *******/

		image__object_free(this_thread->sprite_image_for_delivery);

		this_thread->sprite_image_for_delivery = sprite_image_create( this_thread->base_image_data, frame_number, current_scale);
	
		this_thread->package_ready_for_pickup_flag = yes;

		while ((!this_thread_->package_order_flag) && (!quit)) { 

			usleep (checkflaginterval);
		}
		if(quit){
			/*thread self-terminating code */
			return NULL;
		}
	}/* this is the closing brace of the for( ; ; ) loop */



/*here is a bit of the consumer thread's code *****/


for(int i = 0; i < number_of_sprites; i++){

	if (sprite_threads[i]->package_ready_for_pickup_flag){

		sprite_graphic_free(sprite_threads[i]->package_currently_used);
		sprite_threads[i]->package_currently_used = sprite_threads[i]->package_being_delivered;
		sprite_threads[i]->package_ready_for_pickup_flag = no;
		sprite_threads[i]->package_order_flag = yes;
	}

	sprite_drawing_routine(sprite_threads[i]);
}