구글사는 검색엔진에 이어 웹 3D 부분의 선두주자가 되려 하고 있다. 최근 웹 브라우저에서 작동 시킬 수 있는 3D 그래픽 어플리케이션을 만들 수 있는 오픈소스 자바 스크립트 API인 O3D를 공개하였다. 구글의 Code Labs은 개발자 그룹과의 협업 및 피드박을 받는 그룹이다. O3D는 윈도우와 맥, 그리고 리눅스에서 사용할 수 있다.

   현재 API를 이용하여 다른 소프트웨어에서 만들어진 3D 형태나 건물의 모습을 COLLADA 포맷에서 작동할 수 있도록 한다. 현재 Autodesk 3D Studio Max, Autodesk Maya, Google SketchUp과 기타 일부 CAD 시스템들로부터 이 포맷으로의 export를 할 수 있다.

흥미로운 전개이다. 웹 브라우저에서 어떠한 CAD 소프트웨어로 작성하여도 호환적으로 즐길 수 있는 시대가 열리고 있다. 

SRS
Sound Retrieval System의 약자로 디지털 음원의 녹음 혹은 압축시 손실된 음을 원음의 수준으로 복원시켜준다.

가장 대표적인 3차원 입체 음향 기술로서 Time delay나 Phase shift기술을 사용하지 않아 장시간 음악 감상을 할 때에도

피로감을 주지 않는다.

(너무 올리는 경우 음의 왜곡이 커지고 고사양의 이어폰일 경우에만 높게 설정한다)

TruBass
음향심리학 (Psychoacoustic) 기술을 기반으로 하여 Bass 성능을 향상시키는 특허 기술.

가상의 서브우퍼를 구현하여 깊고 풍부한 Bass를 청취자에게 전달한다.

FOCUS
음향의 이미지 영역을 상승시키고 고주파대역의 명료도를 개선시키는 특허 기술.

SRS 3D와 조합될 때, FOCUS는 훨씬 크고 넓은 음역을 생성하여, 확대된 음향의 이미지를 전달한다.

(손실된 음원을 살려준다)

WOW

음을 수평과 수직으로 확대시켜 공간감을 확장하여 작은 스피커와 헤드폰의 한계를 극복해 준다.

이 기술을 이용하면 작은 오디오기기,포터블 기기등에서 스피커 크기를 확대하지 않고서도 제품의 오디오 성능을 개선할 수 있다.

(이어폰,해드폰의 성능에 맞춰 조절한다. 저사양 이어폰등에 너무 높게 설정하면 음의 왜곡이 커진다)

Definition
보다 생생하고 선명한 사운드를 위한 기술.

이 기술을 통한 깨끗하고 명료한 사운드는 뮤지컬이나 연극의 보컬, 고주파수 대역의 악기 소리를 들을 수 있게 해주며

원본 오디오 음원을 보다 더 세밀하게 들려준다.

(보컬등 음원을 선명하게 해준다. 이어폰사용시는 최대한 낮게 설정한다. 고주파대역이므로 장시간 청취시 상당한 피로감이 동반될수도 있다)

Custom EQ,,,

50 - 저음
200 - 중저음
1k - 중음
3k - 중고음
14k - 고음

Equalizer는 크게 저음,중음,고음 3가지로 나뉜다.

1. 저음

    저음부 와 같은경우는 Bass 라고도 하며. 저음이 강조되게되면 음악의 무게가 향상되고

    비트있는 음악은 더욱 리드미클하게, 발라드 나 뉴에이지 계열등의 음악은 더욱 부드럽게 하고,

    클래식 계열의 음악과 같은경우는 웅장함을 높여주게된다.

    소리 자체의 압력이 강하기 때문에 EQ를 너무 높이 조절하지 않는다.

2. 중저음,중음

    저음부분보다는 가볍지만 되도록 저음부분의 악기를 강조하려고 노력하며

    중저음 부분을 보자면 드럼중에 작은북 (Snare :스네어) 부분과 탐(Tom) 부분을 강조시키는 역할을 한다.

    중음부가 높아지게되면 소리에 마치 파도가 치는듯한 약간 거슬리는 소리가 들리게 되고,

    중음부가 낮아지게되면 마치 비(鼻)음이 섞인듯한 느낌의 소리가 들리게 된다.

3. 중고음,고음

    중고음의 경우 보컬을 부각시켜 준다.

    이 부분과 중음부 에서 조절을 어떤식으로 해주느냐에 따라서 보컬이 답답한지 아니면

    시원한지를 결정 할만큼 보컬에겐 특별한 구간이라 볼수 있다.

    기타와 같은 악기일경우도 마찬가지로 소리가 막히거나 뚫린느낌을 확연하게 느낄수가 있다.

    대신 중음부가 낮아질수록 중음을 강조하는 악기 소리는 점점 들리지 않게 된다.

    이를 주의해서 조절한다.  

    다른 EQ를 모두 줄이고 고음부를 부각시키면 소리의 날카로움을 얻을수 있지만

    고음부가 낮으면 답답하고 맹한 소리가 된다.

2.사원이름에 'N'이 들어가는 모든 사람을 검색하세요.
SELECT * FROM EMP
WHERE ENAME LIKE '%N%';

3.부서번호가 20번이거나 30번 사람중 JOB이 SALESMAN 인 사람을 검색하세요.
SELECT * FROM EMP
WHERE JOB = 'SALESMAN'
AND DEPTNO IN (20, 30);

4.사원번호가 7600번 이상이고, 월급이 2000 이상인 사람을 검색하세요.
SELECT * FROM EMP
WHERE EMPNO>=7600
AND SAL>=2000;

5.사원이름이 KING 인 사람의 JOB과 입사일을 검색하세요.
SELECT JOB, HIREDATE FROM EMP
WHERE ENAME = 'KING';

6.JOB이 SALESMAN이고 COMM이 널이 아닌 사원의 이름과 부서번호(DEPTNO)를 검색하세요.
SELECT ENAME, DEPTNO FROM EMP
WHERE JOB = 'SALESMAN'
AND COMM IS NOT NULL;
 
7.사원의 이름을 내림차순 정렬하세요.
SELECT ENAME FROM EMP
ORDER BY ENAME DESC;

8,1981년 1월 1일 이후에 입사한 사원의 이름과 JOB을 검색하세요.
SELECT ENAME, JOB FROM EMP
WHERE HIREDATE >='81/01/01';

2
1. 임금의 평균을 구하되 소숫점 이하 자리는 버리세요.
SELECT TRUNC(AVG(SAL),0) "AVG"
FROM EMP;

2 월급이 가장 많은 월급과  가장 적은 월급. 그리고 월급 차를 구하세요.

SELECT MAX(SAL) AS MAX MIN(SAL) AS MIN MAX(SAL)-MIN(SAL) AS "MINUS" MINUS
FROM EMP;

3.직업(JOB)별로 월급(SAL)의 평균을 구하세요.

SELECT JOB, AVG(SAL)
FROM EMP
GROUP BY JOB;

4.부서(DEPTNO)별로 임금 (SAL)의 합계를 구하되 합계가 10,000 이상인
부서의 부서와 합계를 구하세요.

SELECT DEPTNO, SUM(SAL)
FROM EMP
GROUP BY DEPTNO
HAVING SUM(SAL) >=10000;

3
사원들의 이름,부서번호,부서이름 출력
SELECT EMP.ENAME, EMP.DEPTNO, DEPT.DNAME
FROM EMP, DEPT
WHERE EMP.DEPTNO = DEPT.DEPTNO;

부서번호가 30번인 사원들의 이름,직급,부서번호,부서위치 출력
SELECT EMP.ENAME, EMP.JOB, DEPT.DEPTNO, DEPT.LOC
FROM EMP, DEPT
WHERE EMP.DEPTNO = DEPT.DEPTNO
AND DEPT.DEPTNO = 30;
 
커미션을 받는 사원의 이름,커미션,부서이름 및 부서위치를 출력
SELECT EMP.ENAME, EMP.COMM, DEPT.DNAME, DEPT.LOC
FROM EMP, DEPT
WHERE EMP.DEPTNO = DEPT.DEPTNO
AND EMP.COMM IS NOT NULL AND EMP.COMM NOT IN(0);

'DALLAS'에서 근무하는 사원의 이름,직급, 부서번호,부서이름
SELECT EMP.ENAME, EMP.JOB, DEPT.DEPTNO, DEPT.DNAME
FROM EMP, DEPT
WHERE EMP.DEPTNO=DEPT.DEPTNO
AND DEPT.LOC = 'DALLAS';

이름에 A가 들어가는 사원들의 이름과 부서이름
SELECT EMP.ENAME, DEPT.DNAME
FROM EMP, DEPT
WHERE EMP.DEPTNO = DEPT.DEPTNO
AND EMP.ENAME LIKE '%A%';

사원이름과 직급,급여,급여등급
SELECT EMP.ENAME, EMP.JOB, EMP.SAL, SALGRADE.GRADE
FROM EMP, SALGRADE
WHERE EMP.SAL BETWEEN SALGRADE.LOSAL AND SALGRADE.HISAL;

//
SELECT E.ENAME, E.JOB,E.SAL, S.GRADE
FROM EMP E, SALGRADE S
WHERE E.SAL >= S.LOSAL AND E.SAL <= S.HISAL

사원이름, 부서번호와 해당 사원과 같은 부서에서 근무하는 사원
SELECT EMP.ENAME, EMP.DEPTNO, DEPT.DNAME
FROM EMP, DEPT
WHERE EMP.DEPTNO = DEPT.DEPTNO
ORDER BY DEPT.DNAME;
(SELF JOIN)

//
select a.ename,a.deptno,b.ename,b.deptno
from emp a,EMP b
where a.deptno = b.deptno
ORDER BY A.Ename;

4
2.사원이름과,급여,입사일을 검색하세요.
SELECT DNAME, SAL, HIREDATE FROM EMP;

3.부서 번호를 한 번씩만 출력되도록 검색하세요.
SELECT DISTINCT DEPTNO FROM DEPT;

4.라인사이지즈를 120으로 세팅하세요.
SET LINESIZE 120;

5."FORD"의 사원 번호와, 이름, 부서번호를 검색하세요.
SELECT EMPNO, ENAME, DEPTNO FROM EMP WHERE ENAME = 'FORD';

6.이름에 "S"가 들어가는 사원의 사원 번호와 이름,부서번호를 검색하세요.
SELECT EMPNO, ENAME, DEPTNO FROM EMP WHERE ENAME LIKE '%S%';

7.이름에 "R"이 들어가고 급여가 3000이상인 사람의 이름과,직급을 검색하세요
SELECT ENAME, JOB, SAL
FROM EMP
WHERE ENAME LIKE '%R%'
AND SAL >=3000;

8.'XXXI LOVE YOUXXX' 에서 'X'를 삭제하고 출력하세요.
SELECT TRIM('X' FROM 'XXXI LOVE YOUXXX')
FROM DUAL

9.사원별로 이름과,직급,연봉(급여에 커미션을 더한 값)을 검색하세요.
SELECT ENAME, JOB, SAL*12+NVL(COMM,0)
FROM EMP

10. EMP 테이블의 행의 갯수를 검색하세요.
SELECT COUNT(*)
FROM EMP

11.부서 번호와 부서별 연봉 평균을 구하세요.
SELECT DEPTNO, AVG(SAL)
FROM EMP
GROUP BY DEPTNO

12.부서번호가 20번인 사원들의 이름, 직급, 부서번호, 부서위치(지역)을 검색하세요.
SELECT E.ENAME, E.JOB, D.LOC, E.DEPTNO
FROM EMP E, DEPT D
WHERE E.DEPTNO = D.DEPTNO
AND E.DEPTNO=20

13. 직급이 'ANALYST' 인 사람의 부서번호, 부서이름, 지역을 출력하세요.
SELECT E.JOB, D.DEPTNO, D.DNAME,D. LOC
FROM EMP E, DEPT D
WHERE E.DEPTNO = D.DEPTNO
AND JOB='ANALYST'

#include <stdio.h>       /* standard I/O routines                 */

#include <pthread.h>     /* pthread functions and data structures */

/* function to be executed by the new thread */

void*  do_loop(void* data)

{

    int i;                      /* counter, to print numbers */

    int j;                      /* counter, for delay        */

    int me = *((int*)data);     /* thread identifying number */

    for (i=0; i<10; i++) {

        for (j=0; j<500000; j++) /* delay loop */

            ;

        printf("'%d' - Got '%d'\n", me, i);

    }

    /* terminate the thread */

    pthread_exit(NULL);

}

/* like any C program, program's execution begins in main */

main(int argc, char* argv[])

{

    int        thr_id;         /* thread ID for the newly created thread */

    pthread_t  p_thread;       /* thread's structure                     */

    int        a         = 1;  /* thread 1 identifying number            */

    int        b         = 2;  /* thread 2 identifying number            */

    /* create a new thread that will execute 'do_loop()' */

    thr_id = pthread_create(&p_thread, NULL, do_loop, (void*)&a);

    /* run 'do_loop()' in the main thread as well */

    do_loop((void*)&b);

    /* NOT REACHED */

    return 0;

}

                 Dining Philosophers Problem

/*  dphil.h    */

typedef struct {

int id;           /* The philosopher's id: 0 to 5 */

long t0;          /* The time when the program started */

long ms;          /* The maximum time that philosopher sleeps/eats */

void *v;          /* The void * that you  define */

int *blocktime;   /* Total time that a philosopher is blocked */

int *blockstarting;  /* If a philosopher is currently blocked, the time that he

                        started blocking */

int phil_count;

pthread_mutex_t *blockmon; /* monitor for blocktime */

} Phil_struct;

extern void *initialize_v(int phil_count);

extern void pickup(Phil_struct *);

extern void putdown(Phil_struct *);

/*

 * dphil_skeleton.c -- Dining philosophers driver program

 */

#include <stdio.h>

#include <pthread.h>

#include "dphil.h"

void *philosopher(void *v)

{

  Phil_struct *ps;

  long st;

  long t;

  ps = (Phil_struct *) v;

  while(1) {

    /* First the philosopher thinks for a random number of seconds */

    st = (random()%ps->ms) + 1;

    printf("%3d Philosopher %d thinking for %d second%s\n",

                time(0)-ps->t0, ps->id, st, (st == 1) ? "" : "s");

    fflush(stdout);

    sleep(st);

    /* Now, the philosopher wakes up and wants to eat.  He calls pickup

       to pick up the chopsticks */

    printf("%3d Philosopher %d no longer thinking -- calling pickup()\n",

            time(0)-ps->t0, ps->id);

    fflush(stdout);

    t = time(0);

    pthread_mutex_lock(ps->blockmon);

    ps->blockstarting[ps->id] = t;

    pthread_mutex_unlock(ps->blockmon);

    pickup(ps);

    pthread_mutex_lock(ps->blockmon);

    ps->blocktime[ps->id] += (time(0) - t);

    ps->blockstarting[ps->id] = -1;

    pthread_mutex_unlock(ps->blockmon);

    /* When pickup returns, the philosopher can eat for a random number of

       seconds */

    st = (random()%ps->ms) + 1;

    printf("%3d Philosopher %d eating for %d second%s\n",

                time(0)-ps->t0, ps->id, st, (st == 1) ? "" : "s");

    fflush(stdout);

    sleep(st);

    /* Finally, the philosopher is done eating, and calls putdown to

       put down the chopsticks */

    printf("%3d Philosopher %d no longer eating -- calling putdown()\n",

    time(0)-ps->t0, ps->id);

    fflush(stdout);

    putdown(ps);

  }

}

main(argc, argv)

int argc;

char **argv;

{

  int i;

  pthread_t *threads;

  Phil_struct *ps;

  void *v;

  long t0, ttmp, ttmp2;

  pthread_mutex_t *blockmon;

  int *blocktime;

  int *blockstarting;

  char s[500];

  int phil_count;

  char *curr;

  int total;

  if (argc != 3) {

    fprintf(stderr, "usage: dphil philosopher_count maxsleepsec\n");

    exit(1);

  }

  srandom(time(0));

  phil_count = atoi(argv[1]);

  threads = (pthread_t *) malloc(sizeof(pthread_t)*phil_count);

  if (threads == NULL) { perror("malloc"); exit(1); }

  ps = (Phil_struct *) malloc(sizeof(Phil_struct)*phil_count);

  if (ps == NULL) { perror("malloc"); exit(1); }

  v = initialize_v(phil_count);

  t0 = time(0);

  blocktime = (int *) malloc(sizeof(int)*phil_count);

  if (blocktime == NULL) { perror("malloc blocktime"); exit(1); }

  blockstarting = (int *) malloc(sizeof(int)*phil_count);

  if (blockstarting == NULL) { perror("malloc blockstarting"); exit(1); }

  blockmon = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));

  pthread_mutex_init(blockmon, NULL);

  for (i = 0; i < phil_count; i++) {

    blocktime[i] = 0;

    blockstarting[i] = -1;

  }

  for (i = 0; i < phil_count; i++) {

    ps[i].id = i;

    ps[i].t0 = t0;

    ps[i].v = v;

    ps[i].ms = atoi(argv[2]);

   ps[i].blocktime = blocktime;

    ps[i].blockstarting = blockstarting;

    ps[i].blockmon = blockmon;

    ps[i].phil_count = phil_count;

    pthread_create(threads+i, NULL, philosopher, (void *) (ps+i));

  }

  while(1) {

    pthread_mutex_lock(blockmon);

    ttmp = time(0);

    curr = s;

    total = 0;

    for(i=0; i < phil_count; i++) {

      total += blocktime[i];

      if (blockstarting[i] != -1) total += (ttmp - blockstarting[i]);

    }

    sprintf(curr,"%3d Total blocktime: %5d : ", ttmp-t0, total);

    curr = s + strlen(s);

    for(i=0; i < phil_count; i++) {

      ttmp2 = blocktime[i];

      if (blockstarting[i] != -1) ttmp2 += (ttmp - blockstarting[i]);

      sprintf(curr, "%5d ", ttmp2);

      curr = s + strlen(s);

    }

    pthread_mutex_unlock(blockmon);

    printf("%s\n", s);

    fflush(stdout);

    sleep(10);

  }

}

/*   dphil_1.c  

          -- Dining philosophers solution #1 -- the null solution */

#include <stdio.h>

#include <pthread.h>

#include "dphil.h"

void pickup(Phil_struct *ps)

{

    return;

}

void putdown(Phil_struct *ps)

{

    return;

}

void *initialize_v(int phil_count)

{

    return NULL;

}

/*   dphil_2.c  

          -- Dining philosophers solution #2 --  */

#include <stdio.h>

#include <pthread.h>

#include "dphil.h"

typedef struct sticks {

  pthread_mutex_t **lock;

  int phil_count;

} Sticks;

void pickup(Phil_struct *ps)

{

  Sticks *pp;

  int i;

  int phil_count;

  pp = (Sticks *) ps->v;

  phil_count = pp->phil_count;

  pthread_mutex_lock(pp->lock[ps->id]);       /* lock up left stick */

  pthread_mutex_lock(pp->lock[(ps->id+1)%phil_count]); /* lock up right stick */

}

void putdown(Phil_struct *ps)

{

  Sticks *pp;

  int i;

  int phil_count;

  pp = (Sticks *) ps->v;

  phil_count = pp->phil_count;

  pthread_mutex_unlock(pp->lock[(ps->id+1)%phil_count]); /* unlock right stick */

  pthread_mutex_unlock(pp->lock[ps->id]);  /* unlock left stick */

}

void *initialize_v(int phil_count)

{

  Sticks *pp;

  int i;

  pp = (Sticks *) malloc(sizeof(Sticks));

  pp->phil_count = phil_count;

  pp->lock = (pthread_mutex_t **) malloc(sizeof(pthread_mutex_t *)*phil_count);

  if (pp->lock == NULL) { perror("malloc"); exit(1); }

  for (i = 0; i < phil_count; i++) {

    pp->lock[i] = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));

    if (pp->lock[i] == NULL) { perror("malloc"); exit(1); }

  }

  for (i = 0; i < phil_count; i++) {

    pthread_mutex_init(pp->lock[i], NULL);

  }

  return (void *) pp;

}

/*

dphil_3.c -- Dining philosophers solution #3 -- putting a

 sleep call in between getting sticks one and two.

 dphil_3.c is the same as dphil_2.c, bt it puts a 1-second delay   between picking up chopstick one and chopstick two.

 You get deadlock instantly as all the philosophers try to pick up

 their chopsticks at once

 */

#include <stdio.h>

#include <pthread.h>

#include "dphil.h"

typedef struct sticks {

  pthread_mutex_t **lock;

  int phil_count;

} Sticks;

void pickup(Phil_struct *ps)

{

  Sticks *pp;

  int phil_count;

  pp = (Sticks *) ps->v;

  phil_count = pp->phil_count;

  pthread_mutex_lock(pp->lock[ps->id]);       /* lock up left stick */

  sleep(3);

  pthread_mutex_lock(pp->lock[(ps->id+1)%phil_count]); /* lock up right stick */

}

void putdown(Phil_struct *ps)

{

  Sticks *pp;

  int i;

  int phil_count;

  pp = (Sticks *) ps->v;

  phil_count = pp->phil_count;

  pthread_mutex_unlock(pp->lock[(ps->id+1)%phil_count]); /* unlock right stick */

  pthread_mutex_unlock(pp->lock[ps->id]);  /* unlock left stick */

}

void *initialize_v(int phil_count)

{

  Sticks *pp;

  int i;

  pp = (Sticks *) malloc(sizeof(Sticks));

  pp->phil_count = phil_count;

  pp->lock = (pthread_mutex_t **) malloc(sizeof(pthread_mutex_t *)*phil_count);

  if (pp->lock == NULL) { perror("malloc"); exit(1); }

  for (i = 0; i < phil_count; i++) {

    pp->lock[i] = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));

    if (pp->lock[i] == NULL) { perror("malloc"); exit(1); }

 }

  for (i = 0; i < phil_count; i++) {

    pthread_mutex_init(pp->lock[i], NULL);

  }

  return (void *) pp;

}

/*

 dphil_4.c -- Dining philosophers solution #4 -- an asymmetrical solution.

 dphil_4.c is the same as dphil_2.c, only odd philosophers start left-hand first, and even

 philosophers start right-hand first. This does not deadlock, even if you put a delay in

 between pickup up chopsticks one and two.

 */

#include <stdio.h>

#include <pthread.h>

#include "dphil.h"

typedef struct sticks {

  pthread_mutex_t **lock;

  int phil_count;

} Sticks;

void pickup(Phil_struct *ps)

{

  Sticks *pp;

  int phil_count;

  pp = (Sticks *) ps->v;

  phil_count = pp->phil_count;

  if (ps->id % 2 == 1) {

    pthread_mutex_lock(pp->lock[ps->id]);       /* lock up left stick */

    pthread_mutex_lock(pp->lock[(ps->id+1)%phil_count]); /* lock right stick */

  } else {

    pthread_mutex_lock(pp->lock[(ps->id+1)%phil_count]); /* lock right stick */

    pthread_mutex_lock(pp->lock[ps->id]);       /* lock up left stick */

  }

}

void putdown(Phil_struct *ps)

{

  Sticks *pp;

  int i;

  int phil_count;

  pp = (Sticks *) ps->v;

  phil_count = pp->phil_count;

  if (ps->id % 2 == 1) {

    pthread_mutex_unlock(pp->lock[(ps->id+1)%phil_count]); /* unlock right stick */

    pthread_mutex_unlock(pp->lock[ps->id]);  /* unlock left stick */

  } else {

    pthread_mutex_unlock(pp->lock[ps->id]);  /* unlock left stick */

    pthread_mutex_unlock(pp->lock[(ps->id+1)%phil_count]); /* unlock right stick */

  }

}

void *initialize_v(int phil_count)

{

  Sticks *pp;

  int i;

  pp = (Sticks *) malloc(sizeof(Sticks));

  pp->phil_count = phil_count;

  pp->lock = (pthread_mutex_t **) malloc(sizeof(pthread_mutex_t *)*phil_count);

  if (pp->lock == NULL) { perror("malloc"); exit(1); }

  for (i = 0; i < phil_count; i++) {

    pp->lock[i] = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));

    if (pp->lock[i] == NULL) { perror("malloc"); exit(1); }

  }

  for (i = 0; i < phil_count; i++) {

    pthread_mutex_init(pp->lock[i], NULL);

  }

  return (void *) pp;

}

/*

 dphil_5.c -- Dining philosophers solution #5 -- Starvation solution  */

#include <stdio.h>

#include <pthread.h>

#include "dphil.h"

#define THINKING 0

#define HUNGRY 1

#define EATING 2

typedef struct {

  pthread_mutex_t *mon;

  pthread_cond_t **cv;

  int *state;

  int phil_count;

} Phil;

void pickup(Phil_struct *ps)

{

  Phil *pp;

  int phil_count;

  pp = (Phil *) ps->v;

  phil_count = pp->phil_count;

  pthread_mutex_lock(pp->mon);

  pp->state[ps->id] = HUNGRY;

  while (pp->state[(ps->id + (phil_count-1))%phil_count] == EATING ||

         pp->state[(ps->id + 1)%phil_count] == EATING) {

    pthread_cond_wait(pp->cv[ps->id], pp->mon);

  }

  pp->state[ps->id] = EATING;

  pthread_mutex_unlock(pp->mon);

}

void putdown(Phil_struct *ps)

{

  Phil *pp;

  int phil_count;

  pp = (Phil *) ps->v;

  phil_count = pp->phil_count;

  pthread_mutex_lock(pp->mon);

  pp->state[ps->id] = THINKING;

  if (pp->state[(ps->id+(phil_count-1))%phil_count] == HUNGRY) {

    pthread_cond_signal(pp->cv[(ps->id+(phil_count-1))%phil_count]);

  }

  if (pp->state[(ps->id+1)%phil_count] == HUNGRY) {

    pthread_cond_signal(pp->cv[(ps->id+1)%phil_count]);

  }

  pthread_mutex_unlock(pp->mon);

}

void *initialize_v(int phil_count)

{

  Phil *pp;

  int i;

  pp = (Phil *) malloc(sizeof(Phil));

  pp->phil_count = phil_count;

  pp->mon = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));

  pp->cv = (pthread_cond_t **) malloc(sizeof(pthread_cond_t *)*phil_count);

  if (pp->cv == NULL) { perror("malloc"); exit(1); }

  pp->state = (int *) malloc(sizeof(int)*phil_count);

  if (pp->state == NULL) { perror("malloc"); exit(1); }

  pthread_mutex_init(pp->mon, NULL);

  for (i = 0; i < phil_count; i++) {

    pp->cv[i] = (pthread_cond_t *) malloc(sizeof(pthread_cond_t));

    if (pp->cv[i] == NULL) { perror("malloc"); exit(1); }

    pthread_cond_init(pp->cv[i], NULL);

    pp->state[i] = THINKING;

  }

  return (void *) pp;

}