void client::run_client_print() {
void *buffer = shmat(shm_id, NULL, 0);
while (1) {
message_to_print.clear();
WaitSemaphore(sem_id, 2);
WaitSemaphore(sem_id, 0);
length = *(int*)buffer;
ReleaseSemaphore(sem_id, 1);
if (length == -1) break;
NumberOfBlocks = ceil((double)length / (double)size_of_buff);
for (int i = 0; i < NumberOfBlocks; i++) {
WaitSemaphore(sem_id, 0);
message_to_print.append((char*)buffer, size_of_buff);
ReleaseSemaphore(sem_id, 1);
}
message_to_print.resize(length);
cout << "Client: ";
for (int i = 0; i < length; i++) {
putchar(message_to_print[i]);
fflush(stdout);
usleep(SLEEP_TIME);
}
cout << endl;
ReleaseSemaphore(sem_id, 3);
}
}
void *start_work(void *sigcache_ptr)
{
SignatureCache *C = sigcache_ptr;
int threadID = atomicFetchAndAdd(&threads_running, 1);
for (;;) {
WaitSemaphore(&sem_jobs_ready);
if (finishup) break;
int currjob = atomicFetchAndAdd(&jobs_start, 1) % JOB_POOL;
jobs[currjob].state = TAKEN;
jobs[currjob].owner = threadID;
ProcessFile(C, jobs[currjob].doc);
jobs[currjob].state = EMPTY;
atomicFetchAndAdd(&jobs_complete, 1);
atomicFetchAndSub(¤t_jobs, 1);
PostSemaphore(&sem_job_avail[currjob]);
}
atomicFetchAndSub(&threads_running, 1);
return NULL;
}
void client::run_client_send() {
void *buffer = shmat(shm_id, NULL, 0);
while (1) {
system("stty -echo");
ReleaseSemaphore(sem_s_id, 0);
WaitSemaphore(sem_c_id, 0);
if (getch_noblock() != -1) {
ReleaseSemaphore(sem_s_id, 1);
message_to_send.clear();
cout << "Server: ";
system("stty echo");
tcflush(STDIN_FILENO, TCIFLUSH);
getline(cin, message_to_send);
system("stty -echo");
ReleaseSemaphore(sems_id, 2);
length = message_to_send.size();
*(int*)buffer = length;
ReleaseSemaphore(sems_id, 0);
WaitSemaphore(sems_id, 1);
NumberOfBlocks = ceil((double)length / (double)size_of_buff);
for (int i = 0; i < NumberOfBlocks; i++) {
message_to_send.copy((char*)buffer, size_of_buff, i*size_of_buff);
ReleaseSemaphore(sems_id, 0);
WaitSemaphore(sems_id, 1);
}
WaitSemaphore(sems_id, 3);
}
usleep(SLEEP_TIME_ONE);
length = *(int*)buffer;
if (length == -1) break;
}
}
void server::server_print()
{
void *bufferer = shmat(shm_id, NULL, 0);
while (1)
{
print_message.clear();
WaitSemaphore(sems_id, 2);
WaitSemaphore(sems_id, 0);
length = *(int*)bufferer;
ReleaseSemaphore(sems_id, 1);
if (length == -1) break;
numberberOfBlocks = ceil((double)length / (double)size_of_buffer);
for (int i = 0; i < numberberOfBlocks; i++)
{
WaitSemaphore(sems_id, 0);
print_message.append((char*)bufferer, size_of_buffer);
ReleaseSemaphore(sems_id, 1);
}
print_message.resize(length);
cout << "Server: ";
for (int i = 0; i < length; i++)
{
putchar(print_message[i]);
fflush(stdout);
usleep(SLEEP_TIME);
}
cout << endl;
ReleaseSemaphore(sems_id, 3);
}
}
void ProcessFile_Threaded(Document *doc)
{
if (jobs_start == -1) {
threads_running = 0;
memset((void *)jobs, 0, sizeof(jobs));
InitSemaphore(&sem_jobs_ready, 0, 0);
for (int i = 0; i < JOB_POOL; i++) {
InitSemaphore(&sem_job_avail[i], 0, 1);
}
threadpool_size = GetIntegerConfig("THREADS", 1)+1;
threadpool = malloc(sizeof(pthread_t) * threadpool_size);
threadcache = malloc(sizeof(SignatureCache *) * threadpool_size);
jobs_start = 0;
jobs_end = 0;
current_jobs = 0;
jobs_complete = 0;
finishup = 0;
threadcache[0] = NewSignatureCache(2, 0);
pthread_create(threadpool+0, NULL, start_work_writer, threadcache[0]);
for (int i = 1; i < threadpool_size; i++) {
threadcache[i] = NewSignatureCache(0, 1);
pthread_create(threadpool+i, NULL, start_work, threadcache[i]);
}
}
int currjob = atomicFetchAndAdd(&jobs_end, 1) % JOB_POOL;
WaitSemaphore(&sem_job_avail[currjob]);
jobs[currjob].doc = doc;
jobs[currjob].state = READY;
atomicFetchAndAdd(¤t_jobs, 1);
PostSemaphore(&sem_jobs_ready);
}
void server::server_send(char *argv)
{
switch (pid)
{
case -1:
printf("New process is not created\n");
return;
case 0:
execlp("mate-terminal", "mate-terminal", "-x", argv, "-n 2", itoa(shm_id),
itoa(sem_id), itoa(sems_id), itoa(sem_server_id), itoa(sem_client_id), NULL);
break;
default:
{
void *bufferer = shmat(shm_id, NULL, 0);
while (1)
{
system("stty -echo");
ReleaseSemaphore(sem_client_id, 0);
WaitSemaphore(sem_server_id, 0);
if (getch_noblock() != -1)
{
ReleaseSemaphore(sem_client_id, 1);
send_message.clear();
cout << "Client: ";
system("stty echo");
tcflush(STDIN_FILENO, TCIFLUSH);
getline(cin, send_message);
system("stty -echo");
ReleaseSemaphore(sem_id, 2);
if (send_message == "exit" || send_message == "end")
{
length = -1;
*(int*)bufferer = length;
ReleaseSemaphore(sem_id, 0);
ReleaseSemaphore(sems_id, 2);
ReleaseSemaphore(sems_id, 0);
ReleaseSemaphore(sem_client_id, 0);
WaitSemaphore(sem_id, 1);
waitpid(pid, NULL, 0);
break;
}
length = send_message.size();
*(int*)bufferer = length;
ReleaseSemaphore(sem_id, 0);
WaitSemaphore(sem_id, 1);
numberberOfBlocks = ceil((double)length / (double)size_of_buffer);
for (int i = 0; i < numberberOfBlocks; i++)
{
send_message.copy((char*)bufferer, size_of_buffer, i*size_of_buffer);
ReleaseSemaphore(sem_id, 0);
WaitSemaphore(sem_id, 1);
}
WaitSemaphore(sem_id, 3);
}
usleep(SLEEP_TIME_ONE);
}
}
break;
}
}
