ㅋ컴구 레포트 ㅜ_ㅜ

이제 이것만 하면 끝이다..쿄쿄쿄

열심히 했으니 에이 뿔 주세요..ㅠ_ㅠ

Botine, C., F. Cazorla, R. Gioiosa, A. Buyuktosunoglu, C.Y. Cher and M. Valero

Proceedings of the 35th International Symposium on Computer Architecture, pp. 415-426, 2008

 

1.     Introduction

ILP 의 한계는 프로세서의 성능을 향상시키는 전략으로서 TLP의 활용을 촉진시키고 있다. Common TLP 패러다임은 Simultaneous Multi-Threading과 Chip-Multi-Processor, 혹은 이 둘의 혼합이다. IBM POWER5는 dual core processor로 각 코어가 두 개의 Thread를 실행한다. Thread는 GCT(reorder buffer), BHT, TLB등의 리소스를 공유하는데, IBM POWER5 시스템은 HW mechanism을 사용하여 Thread 간 리소스를 적절히 분배하고, 여기에 SW/HW co-design을 통해서 8개의 priority level을 갖는 instruction decode rate을 제어 mechanism을 사용한다. SW-controlled priority는 application type에 따라서 throughput과 execution time 모두를 크게 향상시킬 수 있다. 이 논문의 주요 contribution은:

특정한 workload characteristic을 갖는 선택된 micro-benchmark 집합을 가지고 실험하여, 어플리케이션의 실행시간에 대한 POWER5 priority mechanism의 효과를 자세히 분석하였다.

서로 다른 metric, aggregated IPC와 execution time을 향상시키기 위해 POWER5의 priority가 어떻게 사용되는지를 보이는 어플리케이션 case study를 제공한다.

2.  The POWER5 Processor

2.1 Dynamic HW resource balancing

POWER5는 HW dynamic resource balancing을 제공하는데, Thread가 L2 cache의 threshold에 도달하거나, TLB miss이거나, 너무 많은 reorder buffer entry를 사용했을 때, unbalanced한 리소스의 사용이 있다고 판단하여 blocking한다. 

- Stall: congestion이 해결될 때까지 offending thread의 instruction decode를 멈춘다.

- Flush: congestion이 해결될 때까지, dispatch를 기다리고 있는 offending thread의 모든 instruction을 flush하고, 이 Thread가 더 이상 추가적인 instruction을 decode하지 않도록 한다.

2.2 SW-controlled priorities

이 SW-controlled priority는 decode stage에서 HW에 의해 수행되는데, 일반적으로, 높은 우선 순위는 더 높은 수의 decode cycle을 Thread에 할당한다. primary thread(PThread)와 secondary thread(SThread)가 있다고 하고, 각각 PrioP, PrioS의 우선 순위를 가지고 POWER5의 두 코어 중 하나에서 동작한다고 하자.

 …..(1)

R은 PThread와 SThread의 우선 순위의 차이인, PrioP - PrioS를 사용해서 계산된다. 더 높은 우선 순위를 갖는 Thread는 R-1 decode slot을 받고, 낮은 우선 순위를 갖는 Thread는 나머지 slot을 받는다. PThread로 실행되는 프로세서는 SThread로 실행되는 프로세서에게 손해를 주어서 성능이 증가한다. 두 Thread가 같은 우선 순위를 갖는 특별한 경우, slot을 교대로 받는다.

표 1. Software-controlled thread priorities in the IBM POWER5 processor.

POWER5 에서 SW-controlled priority는 0부터 7사이의 값을 갖는데, 그 의미와 변경 권한은 표1과 같다.

우선 순위는 OR instruction으로 변경되는데, OR X,X,X의 형태이며, X는 레지스터의 번호이다. 두 Thread가 모두 우선순위 1을 가질 때는 둘의 차를 0으로 간주하는 것이 아니라, 우선 순위를 가지지 않은 것으로 하여 수행한다.

3.  Evaluation Methodology

POWER5 프로세서에서 SW-controlled priority mechanism의 능력을 알아보기 위해, 프로세서의 특정 성격 한 가지에 초점을 둔 micro-benchmark를 사용한다.

3.1 Running the experiments

이 논문에서는 FAME(FAirly MEasuring Multithreading Architectures) methodology를 사용한다. workload가 steady state로 될 때 그 프로그램의 IPC와 비슷하다면, average accumulated IPC가 대표 값이 될 수 있다. FAME은 average IPC와 steady state IPC의 차이가 threshold이하가 되려면 benchmark가 몇 번 실행되어야 하는지를 결정한다. 이 threshold는 MAIV(Maximum Allowable IPC Variation)이라고 부른다. 이 논문에서는 1%의 MAIV에 도달하기 위해 각 micro-benchmark가 최소 10회 반복되어야 한다.

3.2 Micro-benchmark

      Micro-benchmark는 Integer, Floating point, Memory와 Branch, 네 그룹으로 나뉘어 진다. integer group은 latency가 짧은 cpu_int와 latency가 긴 lng_chain_cpuint를 갖는다. memory group에서는 ldint_l2는 모든 load가 항상 L2 데이터 캐시에 hitting되고, ldint_mem은 메모리에 hitting된다. ldint_l2는 ldint_mem보다 높은 IPC를 갖는다. Branch 그룹에서는 br_hit과 br_miss가 높고 낮은 hit prediction rate을 갖는다. 표2는 벤치마크의 loop body structure를 보여준다. 몇 가지 벤치마크는 똑같이 행동하기 때문에 결과 분석에 영향을 주지 않는 것으로 판단되어, cpu_int, lng_chain_cpuint, ldint_l1, ldint_l2, ldint_mem, cpu_fp만을 다룬다.

표 2 Loop body of the different micro-benchmarks

3.3 The Linux kernel

IBM POWER5에서 동작하는 현재의 Linux kernel(2.6.23)은 아주 적은 경우에 SW-controlled prioritization을 사용하지만, 본 논문에서는 커널 모드에서 사용 가능한 모든 우선 순위를 유저가 set할 수 있는 인터페이스를 제공하는 non-intrusive kernel patch를 만들었다.<!--[if !supportLists]-->ž

•  1부터 6까지의 우선 순위를 유저가 사용할 수 있게 하였다. 0과 7은 유저가 hypervisor call을 하여 사용할 수 있다.

• Linux kernel내의 SW-controlled prioritization을 사용하지 않고, 예측할 수 없는 우선 순위의 변화의 영향만을 실험하였다.

• 유저 어플리케이션이 자신의 우선 순위를 변경할 수 있도록 /sys pseudo file system으로 인터페이스를 제공하였다.

4.  Analysis of the Results

POWER5 prioritization의 확장이 주어진 Thread의 실행에 어떤 영향을 미치는가와 prioritization과 throughput간의 trade-off에 대해 분석한다. 표 3은 두 개의 PThread와 SThread의 우선 순위가 (4,4)인 SMT mode일 때와 single thread mode일 때의 IPC 값을 보여준다.

표 3 IPC of micro-benchmarks in ST mode and in SMT with priorities (4,4). pt stands for PThread and tt for total IPC.

4.1 Effect of Positive Priorities

그림 2는 positive priority(PrioP > PrioS)일 때, SThread의 우선순위 변화에 따른 PThread의 성능 향상을 나타낸다.

일반적으로, 낮은 IPC를 갖고 memory-bound가 아닌, lng_chain_cpuint나 cpu_fp와 같은 thread는 높은 우선 순위로부터 얻는 이득이 적다. ldint_l2와 ldint_mem과 같은 memory-bound benchmark는 다른 memory-bound thread와 함께 작동할 때 prioritization mechanism의 이익을 얻어, ldint_l2의 성능은 240%, ldint_mem의 성능은 70%까지 향상되었다. 반면, cpu_int나 ldint_l1과 같은 높은 IPC의 thread는 추가적인 하드웨어 리소스로부터 이익을 얻을 수 있는 것과 같이 prioritization에 매우 민감했다. 그러므로, prioritization은 보통 total throughput이나 성능을 향상시킨다.

이 결과는 memory-bound benchmark가 유사한 요구조건의 다른 벤치마크와 경쟁할 때, POWER5 prioritization mechanism에 의한 영향을 받는다는 것을 보여준다. 그들은 순수한 cpu-bound benchmark보다는 덜 민감하며, memory-bound benchmark와 co-schedule 되었을 때만 증가된 우선 순위에 대한 이득을 얻는다. 때문에 memory-bound benchmark는 다른 memory-bound benchmark와 스케줄 될 때가 아니면 prioritization되지 않아야 한다.

추가적으로, +2의 우선순위의 차이는 상대적인 포화점을 나타내며, 거의 모든 벤치마크가 자신의 성능의 95%이상에 다다랐다는 것을 의미한다. memory-bound benchmark는 가장 큰 성능의 증가가 +2에서 +3에서 나타나므로 이 규칙의 예외이다.

4.2 Effect of Negative Priorities

그림 3은 ldint_mem을 제외한 모든 마이크로 벤치마크의 성능이 negative priority(PrioP < PrioS)에 의해 큰 영향을 받는 것을 보여준다.

그림 3 Performance degradation of the PThread as its priority decreases with respect to the SThread.

이는 positive priority의 영향보다 훨씬 크다. 그림3의 (f)는 ldint_mem이 다른 ldint_mem thread와 함께 수행되지 않는 경우에는 낮은 우선 순위에 민감하지 않은 것을 보인다. 일반적으로 높은 latency의 메모리 오퍼레이션이나 long dependency chain, 느리고 복잡한 오퍼레이션을 가진 thread는 우선 순위의 감소에 덜 영향을 받는다.

memory-bound benchmark는 다른 thread에 가장 큰 영향을 받는 것 중 하나이다. 우선순위 차가 -2에서 -3으로, -4에서 -5로 변할 때 성능이 명확하게 변화한다.

-5 와 같은 우선순위 차는 Pthread가 오직 memory thread가 남긴 것 만을 얻을 수 있기 때문에, transparent background thread와 같이 성능이 중요하지 않은 경우에만 사용되어야 한다.

+2 의 우선순위 차가 보통 최대 성능에 가깝다고 하면, -3은 성능 손실의 명백한 delta이다. Memory-bound thread의 경우 0부터 -2까지는 큰 성능의 변화가 없다. +2일 때를 고려해보면 대부분의 높은 IPC thread는 그 최대 성능의 95%에 달했고 즉, 우선순위 차가 +2/-2보다 커지는 것을 피해야 한다는 결론을 얻을 수 있다.

4.3 Optimizing IPC Throughput

POWER5 는 낮은 IPC task의 decode를 stalling하거나 시스템의 전반적인 성능을 저하시킬 수 있는 thread를 dispatch하는 등, global throughput을 향상시키는 몇 가지 HW mechanism을 사용하며, 대체로 효과적이다.

그림 4는 총 throughput이 두 배 이상 증가할 수 있는 몇 가지 경우를 보여준다. 이는 우선 순위가 낮은 Thread의 slowdown의 비용에서 얻는 것으로 특히 lng_chain_cpuint와 같이 낮은 우선 순위의 Thread가 낮은 IPC를 가진 경우이다. 이러한 경우는 낮은 IPC의 Thread가 이 slowdown을 커버할 수 있고, 총 throughput이 중점적인 목표일 때 사용될 수 있다.

Cpu-bound benchmark의 성능이 그 우선 순위와 함께 향상되는데 반해 memory-bound benchmark는 상대적으로 일정하게 유지된다. 일반적으로 높은 IPC의 Thread의 우선 순위를 증가시켰을 때 IPC throughput의 향상을 얻을 수 있다. 그림 5는 실제 시스템에서 SW-controlled prioritization이 total IPC 향상에 미치는 영향을 그래프로 나타낸 것이다.

그림 5 Total IPCs with increasing priorities

4.4 Optimizing execution time

높은 throughput이 항상 직접적으로 전체 어플리케이션의 짧은 실행시간으로 대응되는 것은 아니다. 병렬 시스템에서의 load balancing은 동기화된 태스크들이 같은 시간에 완전하게 종료되는 경우가 거의 없기 때문에 어려운 문제이다. 표 4는 prioritization mechanism을 사용해서 전체 성능을 향상시키는 예시이다.

표 4 Execution time, in seconds, of FFT and LU.

 

4.5 Transparent execution

transparent thread는 foreground thread가 full speed로 수행되지 않아도 될 때 background thread가 리소스를 사용할 수 있도록 하는 mechanism이다. POWER5에서는 background thread의 우선순위를 1로 하여 이를 구현하였다. 그림 6의 (a), (b)는 foreground thread가 각각 우선 순위 6과 5 수행될 때 foreground thread에 대한 background thread의 효과에 대한 그래프이다. 대부분의 영향을 받는 thread는 ldint_l1, cpu_int, ldint_l2로 memory-bound thread와 실행되었을 때이다.

그림 6 Primary thread Execution Time with respect to Single-Thread when SThread has priority 1

그림 6의 (c)는 background thread의 우선순위가 6에서 2로 줄어들면서 foreground thread(ldint_l2, cpu_fp, lng_chain_cpuint)에 미치는 최대 효과를 보여준다. ldint_mem을 background로 하여 실행된 foreground thread가 가장 좋지 않은 성능을 보였음을 알 수 있다.

우선 순위가 6에서 2로 갈수록, cpu_fp와 lng_chain_cpuint는 ST 성능의 10% 정도까지 background thread의 효과가 선형적으로 증가한다. ldint_mem은 우선순위 3과 2일 때 갑작스럽게 증가한다. ldint_mem_2의 레이블은 ldint_mem이 foreground로 실행되면서, ldint_mem이 background는 아닐 경우의 성능을 나타낸다. 그래프는 다른 마이크로 벤치마크가 ldint_mem에 미친 효과가 대략 7%인 것을 보여준다. 즉, 자신의 다른 복사본과 함께 수행되지 않는다면, ldint_mem은 항상 큰 성능의 저하 없이 foreground로 수행된다는 결론을 얻을 수 있다.

마지막으로 그림 6의 (d)는 background thread의 성능을 보인다. 각 포인트는 모든 background thread의 평균을 나타내는데 ldint_mem (6, 1)은 ldint_mem과 다른 네 개의 벤치마크, 그리고 자기 자신과의 pair들이 우선순위 6,1로 실행 했을 때의 background thread의 평균이다. 일반적으로 high-latency thread는 가장 좋은 foreground thread, 가장 좋지 않은 background thread가 된다. 그리고 아주 좋은 성능을 갖는 thread는 다른 thread의 영향을 매우 쉽게 받기 때문에 background thread로서 적합하지 않다.

5.  Conclusion

이 논문에서는 SW-controlled prioritization mechanism의 효과를 알아보기 위해 프로세서의 특정 성격에 중점을 둔 마이크로 벤치마크의 집합을 사용하여 심도 깊은 평가를 수행하였다. 이로부터 얻은 결론은 다음과 같다. 첫째로 많은 양의 long-latency operation을 보이는 workload는 low-latency operation을 수행하는 것에 비해 우선 순위에 영향을 덜 받는다. 두 번째로 prioritization mechanism을 사용하여 매우 특별한 경우 두 배 이상의 전반적인 throughput이 향상될 수 있다. 그러나 이러한 극단적인 향상은 낮은 IPC를 갖는 thread의 성능이 대폭 감소함을 의미한다. 조금 덜 극단적인 경우로 40% 정도의 throughput 향상이 가능하다. 세 번째로 우선순위의 full spectrum을 사용하는 대신 +/-2까지 만을 사용하고, 둘 중 하나의 thread가 별로 중요하지 않을 경우에는 "extreme" 우선 순위를 사용한다.

우선 순위가 throughput을 23.7%향상시키고 실행시간을 9.3%줄이며, background thread를 갖는 경우의 case study를 제시하였다. 마지막으로 POWER5의 priority mechanism은 몇 가지 metric을 향상시키는 데 사용될 수 있는 매우 강력한 툴이라는 결론을 내린다. 이 연구는 HW resource를 thread 간에 balancing하는 것을 더 효과적으로 하는 것을 허용하는 SW/HW c-design의 폭넓은 활용으로 가는 길을 열어 주었다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

수업을 좀 빠져서...중간중간에 스킵된 내용을 때우느라고 조금 힘들었다능...
사실 출력 부분이 두 번씩 출력되는 것이...출력문의 위치를 잘못 넣은 것 같긴 하지만
대충 얼추 비슷하게 나오는 것 같아서 그냥 두었다는...
(사실 치명적인 실수가 숨어 있을지 모르지만, 귀찮으니 그냥 넘어간다...지금보니 변수의 철자도 맞지 않는 것이..쿨럭...)

지난 번의 Auction에서 조금 변경된 형태로, 수요자와 공급자가 함께 입찰을 하는 방식이다.
공급자의 가격이 수요자의 요구 가격보다 낮아질 때 낙찰된다.

• Double Auction Model은 기존의 Auction Model이 단 방향성인데 비해서 Supplier와 Customer가 전부 입찰에 참여 할 수 있다.


• Double Auction 모델은 3부분으로 구성되는데 Supplier, Auctioneer, Customer로 구성된다.


• 입찰이 시작되면 Supplier와 Customer가 최초 입찰 가격을 제시 한다.


• 추후 입찰에서 Supplier는 기존 입찰에서 자신의 가격 탄력성 (Price Elasticity) 하에서 입찰 가격을 하락 시켜 입찰하고 Customer는 자신의 가격 탄력성 (Price Elasticity) 하에서 입찰 가격을 상승 시켜 입찰을 진행한다.


• 가격 탄력성의 수치는 입찰 횟수가 많아질수록 상세 가격 조정을 위해 낮아진다.


• SBP(Supplier’s Bidding Price)와 CBP(Customer’s Bidding Price)는 다음과 같다.
  • SBP = Previous Bidding Price of Supplier – Rand(Price Elasticity of Supplier)
  • CBP = Previous Bidding Price of Customer + Rand(Price Elasticity of Customer)


• Supplier와 Customer의 입찰 가격 곡선

PROCESS

1. Auctioneer 가 Supplier와 Customer에게 경매가 시작됐음을 알린다.
2. Supplier와 Customer는 최초 입찰 가격을 Auctioneer에게 보낸다.
3. Auctioneer는 양측의 입찰 가격을 비교하여 가격 균형이 이루어 졌는지 확인해 본 후 가격 균형이 이루어 진 경우 입찰을 종료 하고 아니면 추가 입찰을 통보 한다.
4. Supplier와 Customer는 입찰 가격을 재 조정하여 다시 입찰한다.
   1. SBP = Previous Bidding Price of Supplier – Rand(Price Elasticity of Supplier)
   2. CBP = Previous Bidding Price of Customer + Rand(Price Elasticity of Customer)
5. 3번을 진행한다.
6. 입찰이 종료 되면 종료 메시지와 함께 양측에 입찰 가격을 보낸다.

PROCEDURE and DESIGN

DEVS로 구성 시 만들어지는 1개의 Digraph 모델과 3종류의 Component(Atomic Model)와 4종류의 Message로 구성된다.

• Double Auction: gpt.java를 수정하여 만든다. (Digraph Model)


• Supplier, Auctioneer, Customer: proc.java를 수정하여 만든다.


• 4 Messages: job.java를 수정하여 만든다.
  • Start Message: Auctioneer -> Supplier and Customer로 전달된다. 경매 시작을 알리는 메시지다.
  • Bidding Message: Customer and Supplier -> Auctioneer로 전달되는 메시지로 Customer와 Supplier의 입찰 가격을 포함하고 있다. (# of stage를 포함)
  • Result Message: Auctioneer -> Customer and Supplier로 전달되는 메시지로 양측이 입찰이 끝나면 입찰 가격을 비교 하여 결과를 알려준다. 추가 입찰이 필요한 경우 추가 입찰에 관한 내용도 포함하고 있다.
  • Terminate Message: Auctioneer -> Customer and Supplier로 전달되는 메시지로 경매가 끝났음을 알리는 메시지로 최종 낙찰 가격 (Price Equilibrium)을 가지고 있다.


• Time Out: Stage가 7회 이상되면 가격 절충에 실패한 것으로 간주하여 경매를 종료한다. /* Time out은 구현하지 않았음, ^^;; 좀처럼 7회 안에 낙찰결과를 얻을 수가 없었기때문에..그냥 낙찰될 때까지 두었다. */

EXPERIMENTS

• Supplier에게는 무한의 Product가 있다고 가정 (10000 ~ 20000사이의 가격에서 랜덤하게 설정)


• Product에 대한 Supplier의 Initial Price (First Bidding Price) = 원가 × 1.25


• Customer의 First Bidding Price = FBP of Supplier × 0.85


• 가격 탄력성 PE = (int)(PE×((Stage_Number-1)×0.9)), 단 stage 1의 PE = PE×1이다.
  /* PE = (int)(PE×((Stage_Number-1)×0.99)) 로 변경
  0.9일 때, 낙찰되기 전에 0이 되어 한 건의 낙찰도 이루어지지 않았기 때문에... */


• Result Price = (int)(Last Bidding Price of Supplier + Last Bidding Price of Customer)/2


• 두 개의 Double Auction 모델을 비교
  • Model 1:
    Supplier 와 Customer의 PE = 100 이하의 값 중 랜덤하게 선택
  • Model 2:
    Supplier 와 Customer의 PE = 150 이하의 값 중 랜덤하게 선택
  • Model 3:
    
  • Supplier의 PE = 100 이하 의 값 중 랜덤하게 선택
    Customer의 PE = 150 이하 의 값 중 랜덤하게 선택
  • Model 4:
    Supplier의 PE = 150 이하 의 값 중 랜덤하게 선택
    Customer의 PE = 100 이하 의 값 중 랜덤하게 선택

PERFORMANCE MEASURE

1. 누적 거래 성사 횟수 (SPE = Supplier’s Price Elasticity, CPE = Customer’s Price Elasticity)


2. 평균 입찰 횟수 (SPE = Supplier’s Price Elasticity, CPE = Customer’s Price Elasticity)
   Supplier의 입찰 횟수 합 / 거래성사 횟수


3. Supplier의 평균 이익과 Customer의 평균 지출 (1000, 2000, 3000, 4000, 5000 Devs time)
   Supplier의 평균 이익 = Average (판매가격 – 원가)
   Customer의 평균 지출 = Average (판매 가격)

// DoubleAuction.java
// 2009. 06. 01
// Modified by Aettie Ji

package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class DoubleAuction
    extends ViewableDigraph {
  double cPTime = 50; // Customer processing time
  double sPTime = 50; // Supplier processing time
  double aPTime = 50; // Auctioneer processing time
  double observTime = 10000;

  int SPE = 150; // Price elasticity of supplier
  int CPE = 100; // Price elasticity of customer
  // product initial price
  int[] iniPrice = {
      15400, 12800, 14200, 11400, 18200, 16300, 12900, 10500, 11000, 17900};

  public DoubleAuction() {
    super("DoubleAuction");
    // Customer processing time, initial Price, Customer 가격 탄력성
    ViewableAtomic c =
        new DA_Customer("Customer", cPTime, iniPrice, CPE);
    // Supplier processing time, initial Price, Customer 가격 탄력성
    ViewableAtomic s =
        new DA_Supplier("Supplier", sPTime, iniPrice, SPE);
    // Auctioneer processing time, initial Price, Observation time
    ViewableAtomic a =
        new DA_Auctioneer("Auctioneer", aPTime, iniPrice,
                                         observTime);

    add(c);
    add(s);
    add(a);

    addCoupling(a, "start_out", c, "start_in"); //경매시작
    addCoupling(a, "start_out", s, "start_in");
    addCoupling(a, "result_out", c, "result_in"); //경매결과
    addCoupling(a, "result_out", s, "result_in");

    addCoupling(a, "terminate_out", c, "terminate_in"); //경매종료
    addCoupling(a, "terminate_out", s, "terminate_in");

    addCoupling(s, "bidding_out", a, "sBidding_in"); //입찰
    addCoupling(c, "bidding_out", a, "cBidding_in");

    addCoupling(s, "ACK_out", a, "ACK_in"); //Acknowledgement
    addCoupling(c, "ACK_out", a, "ACK_in");
  }

  public void layoutForSimView() {
    preferredSize = new Dimension(816, 409);
    ( (ViewableComponent) withName("Auctioneer")).setPreferredLocation(new
        Point(414, 121));
    ( (ViewableComponent) withName("Customer")).setPreferredLocation(new Point(
        44, 279));
    ( (ViewableComponent) withName("Supplier")).setPreferredLocation(new Point(
        17, 59));
  }
}

// DA_Auctioneer.java
// 2009. 06. 01
// Modified by Aettie Ji

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;

public class DA_Auctioneer
    extends ViewableAtomic {
  protected entity job;
  protected double processing_time; // Auctioneer의 processing time

  BiddingMessage bm;
  boolean sIn, cIn; // 입찰 여부 체크
  String msgName;
  String portName;
  double clock; //observation time check
  int proCount; // product count
  int cBiddingPrice;
  int sBiddingPrice;
  int terminatePrice; // 낙찰 가격
  double observTime;
  int[] iniPrice; // product initial price

  // 통계를 위한 변수
  int priceEqualibrium; // 거래성사횟수
  double avgBidding; // 평균 입찰 횟수 = Supplier의 입찰 횟수/거래성사횟수
  int sbiddingCnt = 0; // Supplier의 입찰 횟수
  int supplierProfit = 0; // Supplier의 이윤 = 낙찰가격 - 상품원가
  int customerCost = 0; // Customer의 지출 = 낙찰가격
  double avgSProfit = 0; // supplierProfit의 평균
  double avgCCost = 0; // customerCost의 평균

  public DA_Auctioneer(String name, double Processing_time, int[] initial_price,
                       double observation_time) {
    super(name);

    processing_time = Processing_time;
    observTime = observation_time;
    this.iniPrice = initial_price;
    addInport("cBidding_in");
    addInport("sBidding_in");
    addInport("ACK_in");
    addOutport("result_out");
    addOutport("terminate_out");
    addOutport("start_out");
  }

  public void initialize() {
    //phase = "passive";
    holdIn("active", processing_time);
    job = new entity("job");
    msgName = "Start Message";
    portName = "start_out";
    clock = 0;
    proCount = 0;
    cBiddingPrice = 0;
    sBiddingPrice = 0;
    priceEqualibrium = 0;
    terminatePrice = 0;
    avgBidding = 0;
    sIn = false;
    cIn = false;
    //sigma = INFINITY;
    bm = new BiddingMessage("");

    super.initialize();
  }

  public void deltext(double e, message x) {
    clock += e;
    Continue(e);
    if (clock > 10000) { // DEVS time이 10000이면 프로그램 종료
      System.out.println(
          "===============OBSERVATION TIME is OVER!!!=================");
      System.exit(0);
    }
    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "cBidding_in", i)) {
          job = x.getValOnPort("cBidding_in", i);
          bm = (BiddingMessage) job;
          cBiddingPrice = bm.nBiddingPrice;
          cIn = true;
//        System.out.println("Customer Bidding Message in***" + bm.nBiddingPrice);
        }
        if (messageOnPort(x, "sBidding_in", i)) {
          job = x.getValOnPort("sBidding_in", i);
          bm = (BiddingMessage) job;
          sBiddingPrice = bm.nBiddingPrice;
          sIn = true;
          sbiddingCnt++;
//        System.out.println("Supplier Bidding Message in***" + bm.nBiddingPrice);
          holdIn("busy", processing_time);
        }
        if (messageOnPort(x, "ACK_in", i)) {
          job = x.getValOnPort("ACK_in", i);
          msgName = "Start Message";
          portName = "start_out";
//         System.out.println("ACK Message in****************" );
          holdIn("busy", processing_time);
        }
        if (cIn == true && sIn == true) {
//         System.out.println("Both Bidding Message in****************");
          msgName = "Result Message";
          portName = "result_out";
          if (sBiddingPrice <= cBiddingPrice) {//Supplier의 가격이 낮거나 같으면 경매 성사
//           System.out.println("sBiddingPrice <= cBiddingPrice****************");
            if ( (sBiddingPrice != 0) && (cBiddingPrice != 0)) {
              terminatePrice = (int) (Math.round( (double) ( (sBiddingPrice +
                  cBiddingPrice) / 2)));
              msgName = "Terminate Message";
              portName = "terminate_out";
              priceEqualibrium++; // 경매 성사 횟수 증가
              // Supplier의 이윤 = 낙찰가격 - 상품원가
              supplierProfit += (terminatePrice - iniPrice[proCount]);
              // Customer의 지출 = 낙찰가격
              customerCost += terminatePrice;
              System.out.println(
                  "#################### Auctioneer MSG ####################");
              System.out.println("InitPrice: " + iniPrice[proCount]);
              System.out.println("DEVS clock: " + clock);
              System.out.println("Number of Price equalibrium: " +
                                 priceEqualibrium);
              System.out.println("Supplier's Bidding Price: " + sBiddingPrice);
              System.out.println("Customer's Bidding Price: " + cBiddingPrice);
              System.out.println("Last Price: " + terminatePrice);
              System.out.println(
                  "################ End of Auctioneer MSG #################");
              sBiddingPrice = 0;
              cBiddingPrice = 0;
              terminatePrice = 0;
              proCount++;
              sIn = false;
              cIn = false;
              if (proCount >= iniPrice.length) {
                proCount = 0;
              }
            }
          }
        }
        if (clock % 1000 == 0) { // DEVS time 1000마다 각 통계치 출력
          if (priceEqualibrium != 0) {
            avgBidding = (double) sbiddingCnt / (double) priceEqualibrium;
            avgSProfit = (double) supplierProfit / (double) priceEqualibrium;
            avgCCost = (double) customerCost / (double) priceEqualibrium;
            System.out.println(
                "============================================================");
            System.out.println("DEVS clock :" + clock);
            System.out.println("Supplier Bidding Count :" + sbiddingCnt);
            System.out.println("Number of Price equibrium: " + priceEqualibrium);
            System.out.println("Average Bidding: " + avgBidding);
            System.out.println("Average Supplier Profit :" + avgSProfit);
            System.out.println("Average Customer Cost :" + avgCCost);
            System.out.println(
                "============================================================");
          }
        }

      }
    }
  }

  public void deltint() {
    clock = clock + sigma;
    passivate();
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();
    if (msgName == "Start Message") {
      content con = makeContent(portName, new StartMessage("Start Message"));
      m.add(con);
//      System.out.println(
//                "=====Start Message out from: Auctioneer to: S and C=====");
    }
    else if (msgName == "Result Message") {
      content con = makeContent(portName,
                                new ResultMessage("Result Message",
                                                  cBiddingPrice,
                                                  sBiddingPrice));
      m.add(con);
//     System.out.println(
//                "=====Result Message out from: Auctioneer to: S and C====="
//                 +"C: "+cBiddingPrice+"S: "+sBiddingPrice);
    }
    else if (msgName == "Terminate Message") {
      content con = makeContent(portName,
                                new TerminateMessage("Terminate Message",
          terminatePrice));
      m.add(con);
//    System.out.println(
//              "=====Terminate Message out from: Auctioneer to: S and C====="
//               +terminatePrice);
    }
    return m;
  }

  public void showState() {
    super.showState();
    System.out.println("job: " + job.getName());
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

// DA_Supplier.java
// 2009. 06. 01
// Modified by Aettie Ji

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;

public class DA_Supplier
    extends ViewableAtomic {

  protected entity job;
  double sPTime; // processing time
  int iniSPE; // initial price elasticity
  int nFinaliniSPE;

  int[] aIniPrice; // 초기 가격 저장
  int iniPrice, proCnt, sBiddingPrice, resultPrice; // Bidding price+price elasticity
  int nStage = 0;
  String msgName, portName; // message name, port name

  StartMessage sm; // Auctioneer로부터 받은 initial price
  ResultMessage rm; // 이전 입찰정보
  TerminateMessage tm; // 낙찰 정보

  public DA_Supplier(String name, double SPT, int[] AIP, int SPE) {
    super(name);
    this.sPTime = SPT;
    this.aIniPrice = AIP;
    this.iniSPE = SPE;
    nFinaliniSPE = iniSPE;

    addInport("start_in");
    addInport("result_in");
    addInport("terminate_in");
    addOutport("ACK_out");
    addOutport("bidding_out");
  }

  public void initialize() {
    phase = "passive";
    sigma = INFINITY;
    job = new entity("job");
    iniPrice = 0;
    proCnt = 0;
    sBiddingPrice = 0;
    resultPrice = 0;

    sm = new StartMessage("");
    rm = new ResultMessage("");
    tm = new TerminateMessage("");

    super.initialize();
  }

  public void deltext(double e, message x) {
    Continue(e);

    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "start_in", i)) {
          job = x.getValOnPort("start_in", i);
          sm = (StartMessage) job;
          iniPrice = aIniPrice[proCnt];
          sBiddingPrice = (int) (Math.round(iniPrice * 1.25)); //초기입찰가격
          msgName = "Bidding Message";
          portName = "bidding_out";
        }
        else if (messageOnPort(x, "result_in", i)) {
          job = x.getValOnPort("result_in", i);
          rm = (ResultMessage) job;
          // System.out.println(
          //    "========Result Message in from: Auctioneer to:S========" +
          //     rm.sBidPrice);
          resultPrice = rm.sBidPrice; //result message 변수 체크
          if (nStage == 1) { //customer에도 같은 작업
            iniSPE = iniSPE;
          }
          else {
            iniSPE = (int) ( (double) iniSPE * (double) 0.99);
            // 원래는 * 0.9지만 몇 차례 입찰 후 iniCPE가 0이 되어 입찰이 진행되지 않기 때문에 변경
          }
          sBiddingPrice = resultPrice - ( (int) (Math.random() * iniSPE)); //새로운 입찰가격
          //  System.out.println(
          //     "SSresultPrice: " + sBiddingPrice + " =  SSresultPrice :" +
          //     resultPrice + " ((int)(Math.random()*iniSPE)): " +
          //     ( (int) (Math.random() * iniSPE)));
          nStage++; //customer에도 같은 작업
          msgName = "Bidding Message"; // 새로운 입찰 가격을 보냄
          portName = "bidding_out";
        }
        else if (messageOnPort(x, "terminate_in", i)) {
          job = x.getValOnPort("terminate_in", i);
          tm = (TerminateMessage) job;
          //   System.out.println("TerminateMessage  out***************");
          iniSPE = nFinaliniSPE; //customer에도 같은 작업
          sBiddingPrice = 0;
          proCnt++; //한 개 상품에 대한 입찰 종료, 다음상품 경매
          //  System.out.println("한 개 상품에 대한 입찰 종료, 다음상품 경매********");
          if (proCnt >= aIniPrice.length) {
            proCnt = 0;
          }
          msgName = "ACK Message";
          portName = "ACK_out";
        }
        holdIn("active", sPTime);
      }
    }
  }

  public void deltint() {
    passivate();
    job = new entity("none");
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();
    if (msgName == "Bidding Message") {
      content con = makeContent(portName,
                                new BiddingMessage(msgName, sBiddingPrice));
      m.add(con);
      // System.out.println("Bidding Message out*********" + sBiddingPrice);
    }
    else if (msgName == "ACK Message") {
      content con = makeContent(portName, new BiddingMessage("ACK Message"));
      m.add(con);
      // System.out.println("Supplier ACK Message  out**********");
    }
    return m;
  }

  public void showState() {
    super.showState();
    System.out.println("job: " + job.getName());
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

// DA_Customer.java
// 2009. 06. 01
// Modified by Aettie Ji

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;

public class DA_Customer
    extends ViewableAtomic {

  protected entity job;
  double cPTime; // processing time
  int iniCPE; // initial price elasticity
  int nFinaliniCPE;

  int[] aIniPrice; //초기 가격 저장
  int iniPrice, proCnt, cBiddingPrice, resultPrice; //Bidding price + price elasticity
  int nStage = 0;
  String msgName, portName; //message name, port name

  StartMessage sm; //Auctioneer로부터 받은 initial price
  ResultMessage rm; //이전 입찰정보
  TerminateMessage tm; // 낙찰 정보

  public DA_Customer(String name, double CPT, int[] AIP, int CPE) {
    super(name);
    this.cPTime = CPT;
    this.aIniPrice = AIP;
    this.iniCPE = CPE;
    nFinaliniCPE = iniCPE;

    addInport("start_in");
    addInport("result_in");
    addInport("terminate_in");
    addOutport("ACK_out");
    addOutport("bidding_out");
  }

  public void initialize() {
    phase = "passive";
    sigma = INFINITY;
    job = new entity("job");
    iniPrice = 0;
    proCnt = 0;
    cBiddingPrice = 0;
    resultPrice = 0;

    sm = new StartMessage("");
    rm = new ResultMessage("");
    tm = new TerminateMessage("");

    super.initialize();
  }

  public void deltext(double e, message x) {
    Continue(e);

    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "start_in", i)) {
          job = x.getValOnPort("start_in", i);
//          System.out.println(
//             "==========Start Message in from: Auctioneer to: C=========");
          sm = (StartMessage) job;
          iniPrice = aIniPrice[proCnt];
          cBiddingPrice = (int) (Math.round( (iniPrice * 1.25) * 0.85)); //초기입찰가격
          msgName = "Bidding Message";
          portName = "bidding_out";
        }
        else if (messageOnPort(x, "result_in", i)) {
          job = x.getValOnPort("result_in", i);
          rm = (ResultMessage) job;
          //System.out.println(
          //    "=======Result Message in from: Auctioneer to:C==========" +
          //rm.cBidPrice);
          resultPrice = rm.cBidPrice;
          if (nStage == 1) { //customer에도 같은 작업
            iniCPE = iniCPE;
          }
          else {
            iniCPE = (int) ( (double) iniCPE * (double) 0.99);
            // 원래는 * 0.9지만 몇 차례 입찰 후 iniCPE가 0이 되어 입찰이 진행되지 않기 때문에 변경
          }
          cBiddingPrice = resultPrice + ( (int) (Math.random() * iniCPE)); //새로운 입찰가격
          //      System.out.println(
          //          "CCresultPrice: " + cBiddingPrice + " =  CCresultPrice :" +
          //          resultPrice + " ((int)(Math.random()*iniCPE)): " +
          //         ( (int) (Math.random() * iniCPE)));
          nStage++; //customer에도 같은 작업
          msgName = "Bidding Message";
          portName = "bidding_out";
        }
        else if (messageOnPort(x, "terminate_in", i)) {
          job = x.getValOnPort("terminate_in", i);
          //    System.out.println("terminate Message in**********");
          tm = (TerminateMessage) job;
          cBiddingPrice = 0;
          proCnt++; //한 개 상품에 대한 입찰 종료, 다음상품 경매
          //   System.out.println("한 개 상품에 대한 입찰 종료, 다음상품 경매********");
          if (proCnt >= aIniPrice.length) {
            proCnt = 0;
          }
          msgName = "ACK Message";
          portName = "ACK_out";
        }
        holdIn("active", cPTime);
      }
    }
  }

  public void deltint() {
    passivate();
    job = new entity("none");
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();
    if (msgName == "Bidding Message") {
      content con = makeContent(portName,
                                new BiddingMessage(msgName, cBiddingPrice));
      m.add(con);
      // System.out.println("Customer Bidding Message out***************" +
      //                   cBiddingPrice);
    }
    else if (msgName == "ACK Message") {
      content con = makeContent(portName, new BiddingMessage("ACK Message"));
      m.add(con);
      //System.out.println("Customer ACK Message out***************");
    }
    return m;
  }

  public void showState() {
    super.showState();
    System.out.println("job: " + job.getName());
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

//StartMessage.java
// 2009. 06. 01
// Modified by Aettie Ji

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class StartMessage // 새로운 상품의 경매 시작 알림
    extends entity {

  public StartMessage(String name) {
    super(name);
  }
}

// BiddingMessage.java
// 2009. 06. 01
// Modified by Aettie Ji

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class BiddingMessage
    extends entity {

  public int nBiddingPrice; //입찰가격

  public BiddingMessage(String name) {
    super(name);
  }

  public BiddingMessage(String name, int nBiddingPrice) {
    super(name);
    this.nBiddingPrice = nBiddingPrice;
  }
}

// ResultMessage.java
// 2009. 06. 01
// Modified by Aettie Ji

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class ResultMessage // 입찰 결과 메시지
    extends entity {

  public int sBidPrice; // supplier 입찰가격
  public int cBidPrice; // customer 입찰가격

  public ResultMessage(String name) {
    super(name);
  }

  public ResultMessage(String name, int cBidPrice, int sBidPrice) {
    super(name);
    this.sBidPrice = sBidPrice;
    this.cBidPrice = cBidPrice;
  }
}

// TerminateMessage.java
// 2009. 06. 01
// Modified by Aettie Ji

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class TerminateMessage // 해당 상품의 경매 종료 알림
    extends entity {

  public int terminatePrice; // 낙찰가격

  public TerminateMessage(String name) {
    super(name);
  }

  public TerminateMessage(String name, int terminatePrice) {
    super(name);
    this.terminatePrice = terminatePrice;
  }
}

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

사실 내가 작성한 건 아니다...ㅜ_ㅜ
뭐 수업시간에 따라서 코딩하긴 했지만 장기적으로 찾아온 슬럼프때문에 숙제고 수업이고 잠시 손을 놓았었는데
다행히 같이 수업을 듣는 명덕이가 다 작성해줬다..ㅋㅋㅋ
내가 한 건 아니지만 그래도 기록의 의미로 또 포스팅...
(사실 이번 주엔 발표를 해야되는데...난 어떻게 되고 있는지 전혀 모른다는...미안 명덕 ㅡ,.ㅜ)

• MinneTAC Model은 TAC SCM 이라 불리는 공급망 관리를 위한 경쟁 에이전트들 중 하나이며 경매 모델과 같은 경제 모델 중 하나이다.
• 수요자(고객)는 서로 다른 성향을 지니며 각각의 성향에 따라 상품 공급을 요청하고 공급자(에이전트)는 서로 다른 전략을 가지고 중개자를 통해 수요자와의 거래를 성립한다.
• MinneTAC Model은 4개의 부분(Customer, Broker, Bank, Supplier)으로 구성된다.
• 3개의 Customer와 1개의 Broker와 Bank, 2개의 Supplier로 구성된다.

• PROCESS
  
  
  1. 각각의 Customer는 자신의 제안 가격(Offer Price) 범위와 제안 요구량(Offer Demand) 범위 내에서 랜덤하게 상품 공급 요청(RFQ)에 대한 가격과 요구량을 제시하고 해당 거래의 만기일(Due Date)을 함께 제시한다.
  2. Broker는 Customer로부터 받은 RFQ를 기반으로 각각의 Supplier의 전략(MaxEProfit, DemandDriven)에 적합한 Customer와 거래를 중개한다. 동시에 요청된 세 개의 상품 공급 요청(RFQ) 중 기대이익(Profit)이 가장 높은 것은 MaxEProfit 전략을 가진 SupplierA와 거래하고 주문량(Demand)이 가장 많은 것은 DemandDriven 전략을 가진 SupplierB와 거래하도록 한다.
  3. 상품 공급 요청(RFQ)을 받은 각각의 Supplier는 거래 만기일(Due Date) 동안 상품을 생산하여 Customer에게 만들어진 상품을 제공한다고 가정하고 해당 거래가 종료된 후 Broker로부터 다음 거래를 할당 받는다.
  4. 각각의 Supplier는 하나의 거래가 종료될 때마다 해당 거래에 대한 순이익(margin)을 얻게 되는데 이것은 Bank에 누적하여 저장한다.
  5. 각각의 Customer는 일정한 주기로 상품 공급을 요청하고 Broker는 Supplier가 상품을 생산하는 동안 다른 상품 공급 요청(RFQ)이 들어오면 2번부터 4번의 과정을 반복한다.
  6. Customer는 총 50번의 상품 공급 요청 (RFQ)을 발생시키며 50번 이상이 될 경우 시스템을 종료한다.



• PROCEDURE and DESIGN
  
  DEVS로 구성 시 만들어지는 1개의 Digraph 모델과 4종류의 Component(Atomic Model)와 3종류의 Message로 구성된다.
  
  • MinneTAC: gpt.java를 수정하여 만든다. (Digraph Model)
  
  
  • Customer : genr.java를 수정하여 만든다. Customer는 상품 공급에 대한 요청을 위해 RFQ Message를 Broker에게 전송한다. RFQ Message는 상품 공급이 요청된 시간, 제안 가격, 제안 요구량에 대한 정보가 포함된다. [필수 variables] 제안 가격(offer_price), 제안 요구량(offer_demand)
  
  
  • Broker : proc.java를 수정하여 만든다. Broker는 Customer로부터 RFQ Message를 입력 받아 Supplier의 전략에 따라 거래를 진행 할 Customer를 선택하고 해당 Customer의 상품 공급 요청에 대한 정보를 Order Message를 통해 Supplier에게 전달한다. 요청된 상품 공급에 대한 주문은 이전 거래가 완료될 때까지 대기 상태가 되고 이전 거래가 완료되면 순차적으로 처리된다. Broker는 Customer와 Supplier 사이에서 상품 공급 요청을 위한 주문에 대해 중개하는 역할만 한다. 각각의 상품은 시장에서 형성된 실제 시장 가격과 실제 수요량을 기준으로 변화하며 거래 만기일은 Customer의 제안 요구량에 따라 달라진다.
    [필수 variables] 실제 시장 가격(int형 r_price), 실제 수요량(int형 r_demand), 실제 비용(int형 r_cost), 거래 만기일(int형 due_date), 주문 가격(double형 price), 주문 수량(double형 demand), 주문 시간(double형 order_clock), 기대 이익(double형 profit)
  
  
  • Supplier : proc.java를 수정하여 만든다. 자신의 공급 전략을 가지고 Broker로부터 해당 전략에 맞는 주문을 요청 받는다. 해당 주문의 거래 만기일 동안 상품을 생산하고 순이익(margin)을 계산하여 Bank에 저장한다. 각각의 Supplier는 주문을 일정 개수까지는 받은 후 순차적으로 처리하고 이후의 주문에 대해서는 주문을 거절한다.
    [필수 variables] 순이익(double형 margin), 받은 주문 가격(double형 a_price), 받은 주문량(double형 a_quantity), 받은 주문의 기대 이익(double형 a_profit), 받은 주문의 거래 만기일(double형 a_due_date), 주문을 받은 시간(double형 in_clock)
  
  
  • Bank : proc.java를 수정하여 만든다. 각각의 Supplier로부터 순이익(margin)을 받아 저장해준다.
    [필수 variables] 각 Supplier의 순이익(double형 marginA, marginB)
  
  
  • 3 Messages : job.java를 수정하여 만든다.
    RFQ Message: Customer⇒Broker로 전달된다. 상품 공급을 요청하기 위한 메시지로 상품 공급에 대한 요청 시간, 제안 가격, 제안 수량 등의 정보를 포함하며 Broker를 통해 Supplier에게 전달된다.
    [필수 variables] 상품 공급 요청 시간(double형 RFQ_time), 제안 가격(double형 price), 제안 수량(double형 demand)
    Order Message: Customer ⇒ Supplier로 전달되는 메시지로 각각의 Supplier의 전략에 따른 Customer의 주문 정보를 포함한다.
    [필수 variables] 주문 시간(double형 order_time), 주문 가격(double형 price), 주문 수량(double형 quantity), 거래 만기일(double형 due_date)
    Margin Message: Supplier⇒Bank로 전달되는 메시지로 현재 거래에서 발생한 각 Supplier의 순이익(margin)을 저장한다.
    [필수 variables] 순이익(double형 margin)

// MinneTAC.java
// modified by Aettie.Ji
// 2009, May, 5

package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class MinneTAC
    extends ViewableDigraph {

  public MinneTAC() {
    super("MinneTAC");

    addInport("start");
    addInport("stop");
    addOutport("out");
    addOutport("result");

    ViewableAtomic br = new Broker("Broker");
    ViewableAtomic bk = new Bank("Bank");
    ViewableAtomic suA = new MinneSupplier("SupplierA");
    ViewableAtomic suB = new MinneSupplier("SupplierB");
    ViewableAtomic cuA = new MinneCustomer("CustomerA");
    ViewableAtomic cuB = new MinneCustomer("CustomerB");
    ViewableAtomic cuC = new MinneCustomer("CustomerC");

    add(br);
    add(bk);
    add(suA);
    add(suB);
    add(cuA);
    add(cuB);
    add(cuC);

    addCoupling(br, "P_order_out", suA, "order_in");
    addCoupling(br, "Q_order_out", suB, "order_in");
    addCoupling(cuA, "RFQ_out", br, "RFQ_inA");
    addCoupling(cuB, "RFQ_out", br, "RFQ_inB");
    addCoupling(cuC, "RFQ_out", br, "RFQ_inC");

    addCoupling(suA, "margin_outA", bk, "margin_inA");
    addCoupling(suA, "margin_outB", bk, "margin_inB");
    addCoupling(suB, "margin_outA", bk, "margin_inA");
    addCoupling(suB, "margin_outB", bk, "margin_inB");

    addCoupling(suA, "product_outA", cuA, "product_in");
    addCoupling(suA, "product_outB", cuB, "product_in");
    addCoupling(suA, "product_outC", cuC, "product_in");

    addCoupling(suB, "product_outA", cuA, "product_in");
    addCoupling(suB, "product_outB", cuB, "product_in");
    addCoupling(suB, "product_outC", cuC, "product_in");

	showState();
  }

    public void layoutForSimView()
    {
        preferredSize = new Dimension(805, 409);
        ((ViewableComponent)withName("CustomerB")).setPreferredLocation(new Point(367, 113));
        ((ViewableComponent)withName("CustomerA")).setPreferredLocation(new Point(367, 43));
        ((ViewableComponent)withName("Broker")).setPreferredLocation(new Point(-9, 54));
        ((ViewableComponent)withName("CustomerC")).setPreferredLocation(new Point(367, 187));
        ((ViewableComponent)withName("SupplierA")).setPreferredLocation(new Point(-5, 141));
        ((ViewableComponent)withName("Bank")).setPreferredLocation(new Point(363, 265));
        ((ViewableComponent)withName("SupplierB")).setPreferredLocation(new Point(-4, 257));
    }
}

// MinneCustomer.java
// modified by Aettie.Ji
// 2009, May, 5

package SimpArc;

import simView.*;

import java.lang.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import java.util.*;

public class MinneCustomer
    extends ViewableAtomic {

  protected double offer_p;
  protected double offer_d;
  protected entity job;
  protected int offer_num;

  // 상품을 받을 때마다 트렉젠션 완료를 위한 거래수를 기록
  public int transaction_numA, transaction_numB, transaction_numC; 
  public Minne_product product_mess;
  public String customer_name;
  public double RFQ_clock, out_t, in_t, delay_t, genr_t, delay_avg_t;
  int count;

  public MinneCustomer() {
    this("MinneCustomer");
  }

  public MinneCustomer(String name) {
    super(name);
    customer_name = name;

    addInport("product_in");
    addOutport("RFQ_out");

    // Offer_P, Offer_D
    Random r = new Random(System.currentTimeMillis());
    if (name.equals("CustomerA")) {
      offer_p = (r.nextInt(6) + 9.0) / 10; // 0.9~1.5사이의 랜덤값 생성
      offer_d = (r.nextInt(6) + 2.0) / 10;
    }
    else if (name.equals("CustomerB")) {
      offer_p = (r.nextInt(6) + 6.0) / 10;
      offer_d = (r.nextInt(8) + 5.0) / 10;
    }
    else if (name.equals("CustomerC")) {
      offer_p = (r.nextInt(8) + 2.0) / 10;
      offer_d = (r.nextInt(7) + 9.0) / 10;
    }
  }

  public void initialize() {
    transaction_numA = 0;
    transaction_numB = 0;
    transaction_numC = 0;
    count = 0;
    RFQ_clock = 0.9;
    out_t = 0.0;
    in_t = 0.0;
    genr_t = 0.0;
    delay_avg_t = 0;
    product_mess = new Minne_product("product", 0, 0, 0);
    job = new entity("job");

    holdIn("active", 50);
    super.initialize();
  }

// 외부 이벤트를 어떤 port를 통해 받을 것인지
  public void deltext(double e, message x) {
    RFQ_clock = RFQ_clock + e;
    Continue(e);
    //if (phaseIs("passive"))
    {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "product_in", i)) {
          job = x.getValOnPort("product_in", i);
          product_mess = (Minne_product) job;
          double acc_quantity = product_mess.quantity;
          double acc_due_date = product_mess.due_date;
          genr_t = product_mess.order_time;
          in_t = RFQ_clock;
          delay_t = in_t - genr_t - acc_due_date;
          if (delay_avg_t == 0.0) {
            delay_avg_t = delay_t;
          }
          else {
            delay_avg_t = (delay_avg_t + delay_t) / 2;
          }

          if (getName().equals("CustomerA")) {
            transaction_numA++;
          }
          else if (getName().equals("CustomerB")) {
            transaction_numB++;
          }
          else if (getName().equals("CustomerC")) {
            transaction_numC++;
          }
        }
      }
    }
    // phaseIs("active") 일 때는 없음
  }

  public void deltint() {
    RFQ_clock += sigma;
    out_t = RFQ_clock;
    count++;

    if (count > 50) {
      System.exit(0);
    }

    Random r = new Random(System.currentTimeMillis());
    if (name.equals("CustomerA")) {
      offer_p = (r.nextInt(6) + 9.0) / 10; // 0.9~1.5사이의 랜덤값 생성
      offer_d = (r.nextInt(6) + 2.0) / 10;
    }
    else if (name.equals("CustomerB")) {
      offer_p = (r.nextInt(6) + 6.0) / 10;
      offer_d = (r.nextInt(8) + 5.0) / 10;
    }
    else if (name.equals("CustomerC")) {
      offer_p = (r.nextInt(8) + 2.0) / 10;
      offer_d = (r.nextInt(7) + 9.0) / 10;
    }
    if (phaseIs("active")) {
      offer_num++;
      holdIn("active", 50);
    }
    else {
      this.passivate();
    }
  }

  public message out() {
    customer_name = this.getName();
    message m = new message();
    content con = makeContent("RFQ_out",
                              new Minne_RFQ(this.customer_name, out_t, offer_p,
                                            offer_d));
    m.add(con);

    return m;
  }
}

// MinneSupplier.java
// modified by Aettie.Ji
// 2009, May, 5

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;
import java.text.*;

public class MinneSupplier
    extends ViewableAtomic { 
  protected double margin;
  protected entity job;
  protected int queue_size, job_loss;
  protected Queue q;

  public String customer_nm;
  public String supplier_name;
  public double a_profit, a_profit1;
  public double a_quantity, a_quantity1;
  public double a_due_date, a_due_date1;
  public double probability;
  public int transaction_numA, transaction_numB;
  public double in_clock, in_clock1, out_clock;
  Minne_order order_mess, order_mess1;
  public String pattern;
  DecimalFormat df;

  public MinneSupplier() {
    this("MinneSupplier");
  }

  public MinneSupplier(String name) {
    super(name);

    supplier_name = name;
    pattern = "#.00";
    df = new DecimalFormat(pattern);
    queue_size = 5;
    q = new Queue();

    addInport("order_in");
    addOutport("margin_outA");
    addOutport("margin_outB");
    addOutport("product_outA");
    addOutport("product_outB");
    addOutport("product_outC");
  }

  public void initialize() {
    phase = "passive";
    sigma = INFINITY;
    job = new entity("job");
    order_mess = new Minne_order("Order", 0, 0, 0, 0);
    out_clock = 0.0;
    transaction_numA = 0;
    transaction_numB = 0;
    probability = 1.0;

    super.initialize();
  }

  public void deltext(double e, message x) {
    out_clock += e;
    Continue(e);

    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "order_in", i)) {
          job = x.getValOnPort("order_in", i);
          order_mess = (Minne_order) job;
          customer_nm = order_mess.message_name;
          a_profit = order_mess.price;
          a_quantity = order_mess.quantity;
          a_due_date = order_mess.due_date;
          in_clock = order_mess.order_time;
		  // order_in prot로 들어온 order메시지에서 margin을 계산하고
		  // 주문을 제공한 supplier의 transaction number 증가
          margin = Double.parseDouble(df.format( ( (a_profit - 50) * a_quantity *
                                                  probability)));
          if (supplier_name.equals("SupplierA")) {
            transaction_numA++;
          }
          else if (supplier_name.equals("SupplierB")) {
            transaction_numB++;
          }
          this.holdIn("active", a_due_date);
        }
      }
    }
    else if (phaseIs("active")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "order_in", i)) {
          entity job1 = x.getValOnPort("order_in", i);
          order_mess1 = (Minne_order) job1;
          a_profit1 = order_mess1.price;
          a_quantity1 = order_mess1.quantity;
          a_due_date1 = order_mess1.due_date;
          in_clock1 = order_mess1.order_time;
		  // 주문이 queue 사이즈보다 넘치면 job_loss 증가
          if (q.size() < queue_size) {
            q.add(job1);
          }
          else if (q.size() >= queue_size) {
            job_loss = job_loss + 1;
            System.out.println(getName() + " : trade_loss = " + job_loss);
          }
        }
      }
    }
  }

  public void deltint() {
    out_clock += sigma;
    if (!q.isEmpty()) {
      order_mess = (Minne_order) q.first();
      customer_nm = order_mess.message_name;
      a_profit = order_mess.price;
      a_quantity = order_mess.quantity;
      a_due_date = order_mess.due_date;
      in_clock = order_mess.order_time;

      margin = Double.parseDouble(df.format( ( (a_profit - 50) * a_quantity *
                                              probability)));
      if (supplier_name.equals("SupplierA")) {
        transaction_numA++;
      }
      else if (supplier_name.equals("SupplierB")) {
        transaction_numB++;
      }
      q.remove();
      this.holdIn("active", a_due_date);
    }
    else {
      this.passivate();
    }
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();
	// Customer에 따라 product_out port로 product message를 만들어 보낸다.
    if (customer_nm.equals("CustomerA")) { 
      content con1 = makeContent("product_outA",
                                 new Minne_product(this.getName(), in_clock,
          a_due_date, a_quantity));
      m.add(con1);
    }
    else if (customer_nm.equals("CustomerB")) {
      content con1 = makeContent("product_outB",
                                 new Minne_product(this.getName(), in_clock,
          a_due_date, a_quantity));
      m.add(con1);

    }
    else if (customer_nm.equals("CustomerC")) {
      content con1 = makeContent("product_outC",
                                 new Minne_product(this.getName(), in_clock,
          a_due_date, a_quantity));
      m.add(con1);
    }
	// Supplier에 따라 margin_out port로 product message를 만들어 보낸다.
    if (supplier_name.equals("SupplierA")) {
      content con2 = makeContent("margin_outA",
                                 new Minne_margin(this.getName(), margin));
      m.add(con2);
    }
    if (supplier_name.equals("SupplierB")) {
      content con2 = makeContent("margin_outB",
                                 new Minne_margin(this.getName(), margin));
      m.add(con2);
    }

    return m;
  }

  public void showState() {
    super.showState();
    if (job != null) {
      System.out.println("job: " + job.getName());
    }
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

// Broker.java

package SimpArc;

import simView.*;
import java.lang.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import java.io.*;
import java.util.*;
import java.text.*;

public class Broker
    extends ViewableAtomic {

  RandomAccessFile outFile1;
  RandomAccessFile outFile2;
  RandomAccessFile outFile3;
  protected int r_price;
  protected int r_cost;
  protected int random_demand[];
  protected int random_due_date[];
  protected entity job1;
  protected entity job2;
  protected entity job3;
  protected entity job4;

  public double profit[];
  public double due_date[];
  public String customer_name[];
  public double price[];
  public double demand[];
  public double quantity[];
  public double order_clock[];
  public String outA, outB;
  public int r_demand;
  public int r_due_date;
  int random_value;

  Minne_RFQ customer_mess1;
  Minne_RFQ customer_mess2;
  Minne_RFQ customer_mess3;

  Minne_RFQ outport1, outport2;
  public String pattern;
  DecimalFormat df;

  public Broker() {
    this("Market");
  }

  public Broker(String name) {
    super(name);
    File delFile1 = new File("CustomerA_in_Agent.txt");
    if (delFile1.isFile()) {
      delFile1.delete();
    }
    File delFile2 = new File("CustomerB_in_Agent.txt");
    if (delFile2.isFile()) {
      delFile2.delete();
    }
    File delFile3 = new File("CustomerC_in_Agent.txt");
    if (delFile3.isFile()) {
      delFile3.delete();
    }

    try {
      outFile1 = new RandomAccessFile("CustomerA_in_Agent.txt", "rw");
      outFile2 = new RandomAccessFile("CustomerB_in_Agent.txt", "rw");
      outFile3 = new RandomAccessFile("CustomerC_in_Agent.txt", "rw");
      outFile1.writeBytes("============ CustomerA Values ============\n");
      outFile1.writeBytes(getName() + "\t" + "price" + "\t" + "demand" +
                          "\t" + "due_date" + "\n");
      outFile2.writeBytes("============ CustomerB Values ============\n");
      outFile2.writeBytes(getName() + "\t" + "price" + "\t" + "demand" +
                          "\t" + "due_date" + "\n");
      outFile3.writeBytes("============ CustomerC Values ============\n");
      outFile3.writeBytes(getName() + "\t" + "price" + "\t" + "demand" +
                          "\t" + "due_date" + "\n");
    }
    catch (Exception e) {}

    addInport("RFQ_inA");
    addInport("RFQ_inB");
    addInport("RFQ_inC");
    addOutport("P_order_out");
    addOutport("Q_order_out");
  }

  public void initialize() {
    phase = "passive";
    outA = "SupplierA";
    outB = "SupplierB";
    pattern = "#.00";
    df = new DecimalFormat(pattern);
    sigma = INFINITY;
    customer_mess1 = new Minne_RFQ("customer_message", 0, 0, 0);
    customer_mess2 = new Minne_RFQ("customer_message", 0, 0, 0);
    customer_mess3 = new Minne_RFQ("customer_message", 0, 0, 0);
    outport1 = new Minne_RFQ("out_customer", 0, 0, 0);
    outport2 = new Minne_RFQ("out_customer", 0, 0, 0);
    job1 = new entity("job1");
    job2 = new entity("job2");
    job3 = new entity("job3");
    r_price = 100;
    r_cost = 50;
    random_value = 0;
    random_demand = new int[2];
    random_due_date = new int[2];
    random_demand[0] = 1000;
    random_demand[1] = 10;
    random_due_date[0] = 100;
    random_due_date[1] = 10;
    profit = new double[3];
    due_date = new double[3];
    customer_name = new String[3];
    price = new double[3];
    demand = new double[3];
    quantity = new double[3];
    order_clock = new double[3];

    super.initialize();
  }

  public void deltext(double e, message x) {

    Continue(e);
    Random r = new Random();

    random_value = r.nextInt(2);
    if (random_value == 0) {
      r_demand = random_demand[0];
      r_due_date = random_due_date[0];
    }
    else {
      r_demand = random_demand[1];
      r_due_date = random_due_date[1];
    }

    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if ( (messageOnPort(x, "RFQ_inA", i))) {
          job1 = x.getValOnPort("RFQ_inA", i);
          customer_mess1 = (Minne_RFQ) job1;
          customer_name[0] = customer_mess1.RFQ_name;
          price[0] = Double.parseDouble(df.format(customer_mess1.price_rate *
                                                  r_price));
          profit[0] = price[0] - r_cost;
          demand[0] = Double.parseDouble(df.format(customer_mess1.demand_rate *
              r_demand));
          quantity[0] = demand[0];
          order_clock[0] = customer_mess1.RFQ_time;
          // In High Demand
          if (random_value == 0) {
            if (demand[0] <= 200) {
              due_date[0] = Double.parseDouble(df.format( ( (r.nextInt(3) + 1.0) /
                  10) * r_due_date));
            }
            else if (demand[0] > 200 && demand[0] <= 500) {
              due_date[0] = Double.parseDouble(df.format( ( (r.nextInt(5) + 2.0) /
                  10) * r_due_date));
            }
            else if (demand[0] > 500 && demand[0] <= 800) {
              due_date[0] = Double.parseDouble(df.format( ( (r.nextInt(5) + 5.0) /
                  10) * r_due_date));
            }
            else if (demand[0] > 800 && demand[0] <= 1100) {
              due_date[0] = Double.parseDouble(df.format( ( (r.nextInt(5) + 8.0) /
                  10) * r_due_date));
            }
            else if (demand[0] > 1100 && demand[0] <= 1300) {
              due_date[0] = Double.parseDouble(df.format( ( (r.nextInt(4) +
                  11.0) / 10) * r_due_date));
            }
            else if (demand[0] >= 1400) {
              due_date[0] = Double.parseDouble(df.format( ( (r.nextInt(4) +
                  13.0) / 10) * r_due_date));
            }
            else {
              due_date[0] = 0.0;
            }
          }

          try {
            outFile1.writeBytes(getName() + "\t" + price[0] + "\t" +
                                demand[0] + "\t" + due_date[0] + "\n");
          }
          catch (Exception ex) {
            System.out.println("Can't write " + ex);
          }
        }
        if ( (messageOnPort(x, "RFQ_inB", i))) {
          job2 = x.getValOnPort("RFQ_inB", i);
          customer_mess2 = (Minne_RFQ) job2;
          customer_name[1] = customer_mess2.RFQ_name;
          price[1] = Double.parseDouble(df.format(customer_mess2.price_rate *
                                                  r_price));
          profit[1] = price[1] - r_cost;
          demand[1] = Double.parseDouble(df.format(customer_mess2.demand_rate *
              r_demand));
          quantity[1] = demand[1];
          order_clock[1] = customer_mess2.RFQ_time;
          // In High Demand
          if (random_value == 0) {
            if (demand[1] <= 200) {
              due_date[1] = Double.parseDouble(df.format( ( (r.nextInt(3) + 1.0) /
                  10) * r_due_date));
            }
            else if (demand[1] > 200 && demand[1] <= 500) {
              due_date[1] = Double.parseDouble(df.format( ( (r.nextInt(5) + 2.0) /
                  10) * r_due_date));
            }
            else if (demand[1] > 500 && demand[1] <= 800) {
              due_date[1] = Double.parseDouble(df.format( ( (r.nextInt(5) + 5.0) /
                  10) * r_due_date));
            }
            else if (demand[1] > 800 && demand[1] <= 1100) {
              due_date[1] = Double.parseDouble(df.format( ( (r.nextInt(5) + 8.0) /
                  10) * r_due_date));
            }
            else if (demand[1] > 1100 && demand[1] <= 1300) {
              due_date[1] = Double.parseDouble(df.format( ( (r.nextInt(4) +
                  11.0) / 10) * r_due_date));
            }
            else if (demand[1] >= 1400) {
              due_date[1] = Double.parseDouble(df.format( ( (r.nextInt(4) +
                  13.0) / 10) * r_due_date));
            }
            else {
              due_date[1] = 0.0;
            }
          }

          try {
            outFile2.writeBytes(getName() + "\t" + price[1] + "\t" +
                                demand[1] + "\t" + due_date[1] + "\n");
          }
          catch (Exception ex) {
            System.out.println("Can't write " + ex);
          }
        }
        if ( (messageOnPort(x, "RFQ_inC", i))) {
          job3 = x.getValOnPort("RFQ_inC", i);
          customer_mess3 = (Minne_RFQ) job3;
          customer_name[2] = customer_mess3.RFQ_name;
          price[2] = Double.parseDouble(df.format(customer_mess3.price_rate *
                                                  r_price));
          profit[2] = price[2] - r_cost;
          demand[2] = Double.parseDouble(df.format(customer_mess3.demand_rate *
              r_demand));
          quantity[2] = demand[2];
          order_clock[2] = customer_mess3.RFQ_time;
          // In High Demand
          if (random_value == 0) {
            if (demand[2] <= 200) {
              due_date[2] = Double.parseDouble(df.format( ( (r.nextInt(3) + 1.0) /
                  10) * r_due_date));
            }
            else if (demand[2] > 200 && demand[2] <= 500) {
              due_date[2] = Double.parseDouble(df.format( ( (r.nextInt(5) + 2.0) /
                  10) * r_due_date));
            }
            else if (demand[2] > 500 && demand[2] <= 800) {
              due_date[2] = Double.parseDouble(df.format( ( (r.nextInt(5) + 5.0) /
                  10) * r_due_date));
            }
            else if (demand[2] > 800 && demand[2] <= 1100) {
              due_date[2] = Double.parseDouble(df.format( ( (r.nextInt(5) + 8.0) /
                  10) * r_due_date));
            }
            else if (demand[2] > 1100 && demand[2] <= 1300) {
              due_date[2] = Double.parseDouble(df.format( ( (r.nextInt(4) +
                  11.0) / 10) * r_due_date));
            }
            else if (demand[2] >= 1400) {
              due_date[2] = Double.parseDouble(df.format( ( (r.nextInt(4) +
                  13.0) / 10) * r_due_date));
            }
            else {
              due_date[2] = 0.0;
            }
          }

          try {
            outFile3.writeBytes(getName() + "\t" + price[2] + "\t" +
                                demand[2] + "\t" + due_date[2] + "\n");
          }
          catch (Exception ex) {
            System.out.println("Can't write " + ex);
          }
        }

        // 각 Agent에 어느 Customer를 보낼지 outport를 결정
        // MaxEProfit
        double max_p = profit[0];
        if (profit[1] >= max_p) {
          if (profit[2] >= max_p && profit[2] >= profit[1]) {
            outA = "CustomerC";
          }
          else {
            outA = "CustomerB";
          }
        }
        else {
          if (profit[2] >= max_p) {
            outA = "CustomerC";
          }
          else {
            outA = "CustomerA";
          }
        }

        // DemandDriven
        double max_d = demand[0];
        if (demand[1] >= max_d) {
          if (demand[2] > max_d && demand[2] > demand[1]) {
            outB = "CustomerC";
          }
          else {
            outB = "CustomerB";
          }
        }
        else {
          if (demand[2] > max_d) {
            outB = "CustomerC";
          }
          else {
            outB = "CustomerA";
          }
        }
      } // for문 종료(외부입력 전부 받아들인) 후
//       System.out.println("11111  " + order_clock[0] + "22222  " + order_clock[1] + " 33333  " + order_clock[2]);
      holdIn("active", 0.0); // 메세지 출력(outport로)시킴
    }
//     else ;// passive가 아니면
  }

  public void deltint() {
    if (phaseIs("active")) {
      passivate();
    }
  }

  public message out() {
    message m = new message();
    double m_profit1 = 0.0;
    double m_quantity1 = 0.0;
    double m_due_date1 = 0.0;
    double m_order_time1 = 0.0;
    double m_profit2 = 0.0;
    double m_quantity2 = 0.0;
    double m_due_date2 = 0.0;
    double m_order_time2 = 0.0;

    if (outA.equals("CustomerA")) {
      m_profit1 = price[0];
      m_quantity1 = quantity[0];
      m_due_date1 = due_date[0];
      m_order_time1 = order_clock[0];
    }
    else if (outA.equals("CustomerB")) {
      m_profit1 = price[1];
      m_quantity1 = quantity[1];
      m_due_date1 = due_date[1];
      m_order_time1 = order_clock[1];
    }
    else if (outA.equals("CustomerC")) {
      m_profit1 = price[2];
      m_quantity1 = quantity[2];
      m_due_date1 = due_date[2];
      m_order_time1 = order_clock[2];
    }

    if (outB.equals("CustomerA")) {
      m_profit2 = price[0];
      m_quantity2 = quantity[0];
      m_due_date2 = due_date[0];
      m_order_time2 = order_clock[0];
    }
    else if (outB.equals("CustomerB")) {
      m_profit2 = price[1];
      m_quantity2 = quantity[1];
      m_due_date2 = due_date[1];
      m_order_time2 = order_clock[1];
    }
    else if (outB.equals("CustomerC")) {
      m_profit2 = price[2];
      m_quantity2 = quantity[2];
      m_due_date2 = due_date[2];
      m_order_time2 = order_clock[2];
    }

    content con1 = makeContent("P_order_out",
                               new Minne_order(outA, m_order_time1, m_profit1,
                                               m_quantity1, m_due_date1));
    content con2 = makeContent("Q_order_out",
                               new Minne_order(outB, m_order_time2, m_profit2,
                                               m_quantity2, m_due_date2));

    m.add(con1);
    m.add(con2);

    return m;
  }

  public void showState() {
    super.showState();
//    System.out.println("price : " + price);
  }

}

// Bank.java
// modified by Aettie.Ji
// 2009, May, 5

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;

public class Bank
    extends ViewableAtomic { //ViewableAtomic is used instead
  //of atomic due to its
  //graphics capability
  protected entity job;
  protected double margin_sum1, margin_sum2;

  public String supplier_name;
  Minne_margin margin_mess;
  int sell_countA, sell_countB;

  public Bank() {
    this("Bank");
  }

  public Bank(String name) {
    super(name);
    // 파일로 기록하려면 이곳에 작업을 추가
    addInport("margin_inA");
    addInport("margin_inB");
  }

  public void initialize() {
    phase = "passive";
    sigma = INFINITY;
    job = new entity("job");

    this.margin_sum1 = 0.0;
    this.margin_sum2 = 0.0;
    this.sell_countA = 0;
    this.sell_countB = 0;

    super.initialize();
  }

  public void deltext(double e, message x) {
    Continue(e);

    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "margin_inA", i)) {
          job = x.getValOnPort("margin_inA", i);
          margin_mess = (Minne_margin) job;
          this.supplier_name = margin_mess.message_name;
          this.margin_sum1 += margin_mess.margin;
          this.sell_countA++;
        }
        else if (messageOnPort(x, "margin_inB", i)) {
          job = x.getValOnPort("margin_inB", i);
          margin_mess = (Minne_margin) job;
          this.supplier_name = margin_mess.message_name;
          this.margin_sum2 += margin_mess.margin;
          this.sell_countB++;
        }
      }
      System.out.println("Bank - margin A : " + margin_sum1);
      System.out.println("Bank - margin B : " + margin_sum2);
      this.holdIn("active", 0.0);
    }
  }

  public void deltint() {
    if (this.phaseIs("active")) {
      passivate();
    }
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();

    return m;
  }

  public void showState() {
    super.showState();
    if (job != null) {
      System.out.println("job: " + job.getName());
    }
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

// Minne_margin.java
// modified by Aettie.Ji
// 2009, May, 5

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class Minne_margin
    extends entity {
  public String message_name; // 메시지 이름
  public double margin; // 마진

  public Minne_margin(String mn, double m) {
    super(message_name);
    this.message_name = mn;
    this.margin = m;
  }
}

// Minne_order.java
// modified by Aettie.Ji
// 2009, May, 5

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class Minne_order
    extends entity {
  public String message_name; // 메시지 이름
  public double price; // 가격
  public double quantity; // 수량
  public double due_date; // 기한
  public double order_time; // 주문일시

  public Minne_order(String mn, double ot, double p,
                     double qty, double dd) {
    super(message_name);
    this.message_name = mn;
    this.price = p;
    this.quantity = qty;
    this.due_date = dd;
    this.order_time = ot;
  }
}

// Minne_product.java
// modified by Aettie.Ji
// 2009, May, 5

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class Minne_product
    extends entity {
  public String message_name; // 메시지 이름
  public double quantity; // 상품량
  public double due_date; // 기한
  public double order_time; // 주문일시

  public Minne_product(String mn, double ot, double dd,
                       double qty) {
    super(message_name);
    this.message_name = mn;
    this.quantity = gty;
    this.due_date = dd;
    this.order_time = ot;
  }
}

// Minne_RFQ.java
// modified by Aettie.Ji
// 2009, May, 5

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class Minne_RFQ
    extends entity {
  public String RFQ_name;
  public double price_rate;
  public double demand_rate;
  public double RFQ_time;

  public Minne_RFQ(String RFQ_name, double RFQ_time, double price_rate,
                   double demand_rate) {
    super(RFQ_name);
    this.RFQ_name = RFQ_name;
    this.price_rate = price_rate;
    this.demand_rate = demand_rate;
    this.RFQ_time = RFQ_time;
  }
}

설명에는 없는 Product message를 하나 더 만들었는데...
아..보지 않아서 잘 모르겠다는..ㅋㅋ
어차피 메시지는 모델간에 정보를 넘겨주는 거기 때문에 안에 가지고 있는 정보가 뭐냐가 중요한 거라는...
몇 개가 되도 상관은 없다..ㅋㅋ

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Semantic Web 발표를 위해 만든 자료...
백업의 의미로 저장해 둔다는...
발표자료는 정말 후딱..거의 하루만에 만들었기 때문에 결코 퀄리티가 높지 않고...
영어로 발표해야 했기 때문에 대본을 만들어서 거의 읽는 수준이었다는..ㅋㅋㅋ


요건 참고자료...
앞 부문은 지금 교재로 쓰고 있는 (말이 좋아 교재지..이 책으로 진도를 나가는 것은 아닌..ㅡ_ㅡ)
“Semantic Web Technologies”, Davies, J., R. Studer and P. Warren, WILEY
요 책의 chapter 9를 리뷰한 거고...
후반부는 NeOn Methodology를 간단하게 소개한 것으로
NeOn project 홈페이지에 가면 공개되어 있는 자료를 바탕으로 했다.


http://www.neon-project.org
NeOn project는 ontology modeling과 life cycle에 대해 아주 전반적이 내용을 다루는 프로젝트라서
홈페이지를 들어가보면 아주 다양하고 방대한 양의 문서자료를 볼 수 있다.


급조한 티가 너무 난다는..ㅜ_ㅜ

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

이번엔 두 시간에 걸친 옥션 모델 만들기였다...
아...빡세더라..ㅋㅋ




Process of Auction Model

1. Supplier가 Auctioneer에게 판매할 상품의 경매를 요청한다. (이때 상품의 초기 시작 가격 (Initial Price)을 같이 보낸다.) ' 위 그림의 청색 라인이 경매 시작 신호선이다.
2. Auctioneer는 N개의 Customer에게 Supplier에게 받은 동일한 메시지를 전달하여 경매가 시작 되었음을 알린다. 
3. 각각의 Customer는 자신만의 가격 탄력성 (Price Elasticity)와 최대 입찰 가능 가격(Maximum Boundary Price)을 가지고 있다. 
4. 최초의 입찰에서는 각각의 Customer가 입찰 가격으로 Auctioneer로부터 전달 받은 초기 입찰 가격에 자신의 가격 탄력성 안에서 가격을 설정(Rand 함수를 이용하여 자신의 가격 탄력성 안에서 랜덤 하게 선택한다.) 하여 입찰 가격을 정해 Auctioneer에게 보낸다. ->빨간색 점선
   First Bidding Price = Initial Price from Auctioneer + Rand(Price Elasticity of Customer)
5. 첫 번째 입찰을 받은 Auctioneer는 최초 입찰에서 최고가를 입찰한 Customer와 입찰 최고가를 각각의 Customer 및 Supplier에게 보낸다.
6. 두 번째 입찰은 Customer가 각각의 자신의 최대 입찰 가격을 넘지 않는 범위에서 최초 입찰 가격에 자신의 가격 탄력성을 더한 가격을 입찰한다. 이미 최초 입찰에서 자신의 최대 입찰 가격을 넘은 Customer는 입찰을 포기(Bidding price = 0) 한다.
   IF (Highest Price of Previous Bidding < Maximun Price Boundary){
        Bidding Price = Highest Price of Previous Bidding + Rand(Price Elasticity of Customer)
   ELSE
        Bidding Price = 0;
7. 5번을 다시 실행 
8. 입찰은 총 5회 진행 된다. (※ 5회 이전에 입찰자가 1명만 남은 경우에는 그 입찰자의 입찰가격을 낙찰 가격으로 하고 경매를 종료 시킨다.) 5회 입찰 진행 후 최고가를 입찰한 Customer가 낙찰되며, 낙찰 가격을 모든 Customer와 Supplier에 공지 하고 경매는 종료 된다. 
9. 경매 종료 메시지를 전달받은 Supplier는 재고에 남아있는 상품의 경매 요청 메시지를 최초 가격과 함께 Auctioneer에게 전달한다. 
10. 1~9의 과정을 반복하여 supplier에 더 이상 재고가 존재하지 않을 경우 시스템을 종료한다.

Procedure and Design

• DEVS로 구성 시 만들어지는 1개의 Digraph 모델과 3종류의 Component(Atomic Model)와 3종류의 Message로 구성된다.
  1. Auction: gpt.java를 수정하여 만든다. (Digraph Model)
  2. Supplier : genr.java를 수정하여 만든다.
     Supplier는 자신의 상품이 저장된 Inventory를 가진다.
     또한, Auctioneer로부터 받은 Result Message를 통해 경매가 종료되었을 경우 Start Message를 전송하여 새로운 상품의 경매를 요청한다.
     [필수 variables] 상품 저장소 (int형 2차원 배열 inventory-상품번호와 시작가격 포함)
  3. Auctioneer : proc.java를 수정하여 만든다.
     Auctioneer는 Supplier로부터 Start Message를 입력받아 경매의 시작을 알린다.
     또한, Customer의 입찰정보를 저장할 리스트를 포함하며 Customer들로부터 Bidding Message를 입력 받아 리스트를 갱신, 최고 입찰자 및 입찰가에 대한 정보를 Result Message를 통해 공지한다.
     [필수 variables] 입찰 리스트 (int형 2차원 배열 bitList - 입찰자와 입찰가격 포함)
     입찰 카운트 (int형 count - 한계값은 5이며 5가 넘을 경우 0으로 셋팅)
     최고 입찰자 (string형 max_bidder), 최고 입찰 가격 (int형 max_price), 낙찰자 (String형 end_bidder), 낙찰 가격 (end_price)
  4. Customer : proc.java를 수정하여 만든다.
     자신의 판매전략에 맞춰 입찰가를 선정하나 만약 선정된 가격이 입찰 한도를 초과할 경우 입찰가를 0으로 조정한다.
     그리고, 만약 경매가 종료되었을 경우에는 Bidding Message를 발생시키지 않고 입찰가를 0으로 재조정한다.
     [필수 variables] 입찰가 (int형 bid_price), 가격 탄력성(int형 PE), 입찰 한도(int형 MBP), 현재가격 (int형 posted_price)
  5. 3 Messages ' job.java를 수정하여 만든다.
     • Start Message: Supplier ' Auctioneer, Auctioneer ' Customer로 전달된다.
       경매 시작을 알리는 메시지로 초기 시작 가격을 가지고 있다.
       [필수 variables] 상품 번호( int형 product_num), 시작가격( int형 initial_price)
     • Bidding Message: Customer ' Auctioneer로 전달되는 메시지로 각 Customer의 정보와 입찰 가격을 포함하고 있다.
       [필수 variables] 입찰자 번호(int형 customer_num), 입찰가격(int형 bidding_price)
     • Result Message: Auctioneer ' Customer, Supplier로 전달되는 메시지로 현재 경매의 진행 상황 및 최고가와 최고가를 입찰한 Customer의 정보를 포함한다.
       [필수 variables] 진행상황(string형 status), 최고가(int형 highest_price), 최고입찰자(string형 highest_bidder)

Supplier inverntory 내의 10개의 product와 그 초기 가격      1     PD#1     2000
     2      PD#2      2200
     3      PD#3      1800
     4      PD#4      1600
     5      PD#5      2500
     6      PD#6      3000
     7      PD#7      3300
     8      PD#8      2800
     9      PD#9      1900
    10      PD#10     3500

Customer의 최대 입찰 가격과 입찰 탄력성
     Cus #1      (Initial Price of Product)* 2.0      240
     Cus #2      (Initial Price of Product)* 2.2      220
     Cus #3      (Initial Price of Product)* 1.9      260
     Cus #4      (Initial Price of Product)* 2.4      300
     Cus #5      (Initial Price of Product)* 2.1      280


총 7개의 파일을 작성했으며, 개략적인 내용은 주석으로 확인하시길...(좀 질렸음...ㅋㅋ)
어디서 오류가 나는지 잡기 위해서 중간 중간 프린트문을 넣었는데
모두 주석처리한 채로 그냥 두었다.
결과는 파일로 출력된다.

// SingleAuction.java
// modifued by Aettie Ji
// April 21st, 2009
package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class SingleAuction
    extends ViewableDigraph {
  int customer_num = 5;
  double customer_inform[][]; // customer_inform

  public SingleAuction() {
    super("SingleAuction");
    customer_inform = new double[customer_num][2]; // customer_inform
    customer_inform[0][0] = 2.0; // 최고입찰가격
    customer_inform[0][1] = 240; // 가격 탄력성
    customer_inform[1][0] = 2.2; // 최고입찰가격
    customer_inform[1][1] = 240; // 가격 탄력성
    customer_inform[2][0] = 1.9; // 최고입찰가격
    customer_inform[2][1] = 260; // 가격 탄력성
    customer_inform[3][0] = 2.4; // 최고입찰가격
    customer_inform[3][1] = 300; // 가격 탄력성
    customer_inform[4][0] = 2.1; // 최고입찰가격
    customer_inform[4][1] = 280; // 가격 탄력성

    ViewableAtomic s = new Auction_Supplier("Supplier", 0);
    ViewableAtomic a = new Auctioneer("Auctioneer", customer_num);

    for (int i = 0; i < customer_num; i++) {
      String customer_name = "Customer_" + i;
      double MBP = customer_inform[i][0];
      double PE = customer_inform[i][1];
      ViewableAtomic c = new Auction_Customer(customer_name, i, MBP, PE);
      add(c);
      addCoupling(c, "bidout", a, "bidin" + i);
      addCoupling(a, "start", c, "in");
      addCoupling(a, "out", c, "pricein");
    }

    add(s);
    add(a);

    addCoupling(s, "start", a, "in");
    addCoupling(a, "out", s, "result");
    //    initialize();
    showState();
    /*
      preferredSize = new Dimension(484, 145);
      g.setPreferredLocation(new Point(13, 18));
      p.setPreferredLocation(new Point(195, 18));
      t.setPreferredLocation(new Point(193, 80));
     */
  }

  /**
   * Automatically generated by the SimView program.
   * Do not edit this manually, as such changes will get overwritten.
   */
  public void layoutForSimView() {
    preferredSize = new Dimension(816, 409);
    ( (ViewableComponent) withName("Customer_2")).setPreferredLocation(new
        Point(528, 173));
    ( (ViewableComponent) withName("Customer_0")).setPreferredLocation(new
        Point(502, 15));
    ( (ViewableComponent) withName("Supplier")).setPreferredLocation(new Point(
        50, 144));
    ( (ViewableComponent) withName("Customer_1")).setPreferredLocation(new
        Point(520, 105));
    ( (ViewableComponent) withName("Customer_4")).setPreferredLocation(new
        Point(516, 340));
    ( (ViewableComponent) withName("Customer_3")).setPreferredLocation(new
        Point(490, 247));
    ( (ViewableComponent) withName("Auctioneer")).setPreferredLocation(new
        Point(238, 102));
  }
}

// Acution_Supplier.java
// modifued by Aettie Ji
// April 21st, 2009
package SimpArc;

import simView.*;

import java.lang.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class Auction_Supplier
    extends ViewableAtomic {

  protected double int_arr_time;
  protected int count;
  protected entity job;
  double inventory[][];
  result_message r_msg;

  public Auction_Supplier(String name, double Int_arr_time) {
    super(name);
    addInport("result");
    addOutport("start");
    int_arr_time = Int_arr_time;
  }

  public void initialize() {
    holdIn("active", int_arr_time);
    job = new entity("job");
    r_msg = new result_message("RESULT", "end", "", 0);

    //  phase = "passive";
    //  sigma = INFINITY;
    count = 0;
    inventory = new double[10][2];
    inventory[0][0] = 1;
    inventory[0][1] = 2000;
    inventory[1][0] = 2;
    inventory[1][1] = 2200;
    inventory[2][0] = 3;
    inventory[2][1] = 1800;
    inventory[3][0] = 4;
    inventory[3][1] = 1600;
    inventory[4][0] = 5;
    inventory[4][1] = 2500;
    inventory[5][0] = 6;
    inventory[5][1] = 3000;
    inventory[6][0] = 7;
    inventory[6][1] = 2300;
    inventory[7][0] = 8;
    inventory[7][1] = 2800;
    inventory[8][0] = 9;
    inventory[8][1] = 1900;
    inventory[9][0] = 10;
    inventory[9][1] = 3500;
    super.initialize();
  }

  public void deltext(double e, message x) {
    Continue(e);
    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "result", i)) {
          job = x.getValOnPort("result", i);
          r_msg = (result_message) job;
          //System.out.println("Result Port로 Auctioneer로부터 결과 메시지 받음");
          if (r_msg.status == "progree") { //경매진행중, 판매요청불가
            phase = "passive";
            //System.out.println("결과 메시지의 status == progree, 경매진행중");
          }
          else if (r_msg.status == "end") { //경매종료, 판매요청가능
            count++;
            //System.out.println("결과 메시지의 status == end" + "\t" + (count - 1) +
            //                   " 번 째 상품 경매종료");
            if (count < 10) {
              //System.out.println("=====================" + count +
              //                   "번째 경매 대기=======================");
              holdIn("active", int_arr_time);
            }
            else {
              System.exit(0);
            }

          }
        }
      }
    }
  }

  public void deltint() {
    passivate();
    job = new entity("none");
  }

  public message out() {

//System.out.println(name+" out count "+count);

    message m = new message();
    content con = makeContent("start",
                              new start_message("START", inventory[count][0],
                                                inventory[count][1]));
    m.add(con);
    /*System.out.println("start port로 Auctioneer에게 시작 메시지보냄: " + "\n" +
                       "================" + count +
                       "번째 경매 시작: " + "Inventory : " + inventory[count][0]
                       + "\t" + "Initial Price : " + inventory[count][1] +
                       "==============");*/
    return m;
  }

  public void showState() {
    super.showState();

  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + " int_arr_time: " + int_arr_time
        + "\n" + " count: " + count;
  }

}

// Auctioneer.java
// modifued by Aettie Ji
// April 21st, 2009
package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;
import java.io.RandomAccessFile;

public class Auctioneer
    extends ViewableAtomic {
  protected entity job;
//protected double processing_time;
  double list[][];
  double sort[][];
  int count; //입찰카운트, 총 5회진행
  String max_bidder; //최고입찰자
  double max_price; //최고입찰가

//경매기록 파일 작성
  RandomAccessFile out;

  start_message s_msg;
  bidding_message b_msg;
  int customer_num; //경매참여자수
  int case_num; //어떤 메시지 입력을 받는가 구별
  int check[]; //입찰자의 입찰여부 체크
  double temp1, temp2; //정렬 등을 위한 임시변수
  String status; //현재 상태를 받기위한 변수

  public Auctioneer() {
    this("Auctioneer", 20);
  }

  public Auctioneer(String name, int num) {
    super(name);
    customer_num = num;
    list = new double[customer_num][2];
    sort = new double[customer_num][2];
    check = new int[customer_num];
    for (int i = 0; i < customer_num; i++) {
      addInport("bidin" + i); //각 customer bidout과 연결
      list[i][0] = i;
      list[i][1] = 1;
      sort[i][0] = i;
      sort[i][1] = 1;
      check[i] = 0;
    }
    addInport("in"); //start message from supplier
    addOutport("out"); //result message to supplier
    //addOutport("priceout");
    addOutport("start");
    try {
      out = new RandomAccessFile("biddingHistory.txt", "rw");
      System.out.println(
          "****************************파일생성***************************");
    }
    catch (Exception e) {
      System.out.println("Can't open file " + e);
    }
  }

  public void initialize() {
    phase = "passive";
    sigma = INFINITY;
    job = new entity("job");
    max_bidder = "";
    max_price = 0;
    count = 0;
    case_num = 0;
    temp1 = 0;
    temp2 = 0;
    s_msg = new start_message("START", 0, 0);
    b_msg = new bidding_message("BID", 0, 0);
    super.initialize();
  }

  public void deltext(double e, message x) {
    Continue(e);

    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "in", i)) {
          job = x.getValOnPort("in", i);
          s_msg = (start_message) job;
          //System.out.println("In Port로 supplier로부터 시작 메시지 받음");
          try {
            out.writeBytes("Product Num : " + s_msg.product_num + "\t"
                           + "Initial Price : " + s_msg.initial_price + "\n");
          }
          catch (Exception ex) {
            System.out.println("Can't Write " + ex);
          }
          case_num = 1;
          holdIn("busy", 0);
          }
      }
      for (int j = 0; j < customer_num; j++) {
        for (int i = 0; i < x.getLength(); i++) {
          if (messageOnPort(x, "bidin" + j, i)) {
            job = x.getValOnPort("bidin" + j, i);
            b_msg = (bidding_message) job;
            //System.out.println("Bidin Port로 customer로부터 입찰 메시지 받음");
            list[j][0] = b_msg.customer_num;
            list[j][1] = b_msg.bidding_price;
            if (list[j][1] == 0) {
              check[j] = 0;
              //System.out.println("Customrt_" + j + "는 입찰하지 않았음");
            }
            else if (list[j][1] != 0) {
              check[j] = 1;
              case_num = 2;
              //System.out.println("Customrt_" + j + "는 입찰 하였음");
            }
          }
        }
      }
      if (case_num == 2) {
        count++;
        //System.out.println(count + " 번째 입찰======================");
        for (int k = 0; k < customer_num; k++) {
          sort[k][0] = list[k][0];
          sort[k][1] = list[k][1];
        }
        //bubble sort
        for (int a = 0; a < customer_num - 1; a++) {
          for (int b = a + 1; b < customer_num; b++) {
            if (sort[a][1] > sort[b][1]) {
              temp1 = sort[a][0];
              sort[a][0] = sort[b][0];
              sort[b][0] = temp1;
              temp2 = sort[a][1];
              sort[a][1] = sort[b][1];
              sort[b][1] = temp2;
              //System.out.println("Sorting");
            }
          }
        }

        max_bidder = "Customer " + sort[0][0];
        max_price = sort[0][1];
        //System.out.println("max_bidder :" + max_bidder + "\t" + "max_price :" +
        //                   max_price);
        try {
          out.writeBytes("----------Bidding count : " + count + "---------" +
                         "\n");
          for (int b = 0; b < customer_num; b++) {
            out.writeBytes("Customer :" + list[b][0] + "\t" + list[b][1] +
                           "\n"); //경매과정 list[][]출력
          }
          out.writeBytes("Max Bidder :" + max_bidder + "\t" + "Max Price :" +
                         max_price + "\n"); //누가 maxbidder인지 출력
        }
        catch (Exception ex) {
          System.out.println(ex);
        }
        holdIn("busy", 0);
      }
    }
  }

  public void deltint() {
    passivate();
    job = new entity("none");
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();
    if (phaseIs("busy")) {
      if (case_num == 1) {
        m.add(makeContent("start", s_msg));
        //System.out.println("Start Port로 customer에게 시작 메시지 보냄");
      }
      else if (case_num == 2) {
        if (count < 5) {
          int participant = 0;
          for (int a = 0; a < customer_num; a++) {
            participant += check[a];
          }
          //System.out.println(participant + " 명 입찰");
          if (participant >= 2) {
            status = "progree";
          }
          else {
            count = 0;
            status = "end";
          }
        }
        else if (count >= 5) {
          count = 0;
          status = "end";
        }
        m.add(makeContent("out",
                          new result_message("RESULT", status, max_bidder,
                                             max_price)));
        //System.out.println("Out port로 Supplier, Customer에게 결과 메시지보냄: " + "\n" +
        //                   "상태 : " + status + "MaxBidder : " + max_bidder
        //                   + "\t" + "MaxPrice : " + max_price);
      }
    }
    return m;
  }

  public void showState() {
    super.showState();
//    System.out.println("job: " + job.getName());
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

// Auction_Customer.java
// modifued by Aettie Ji
// April 21st, 2009
package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;

public class Auction_Customer
    extends ViewableAtomic { 
  protected entity job;
  int num;
  double bid_price; //입찰가
  double PE; //가격 탄력성
  double MBP; //최고입찰한도
  double real_MBP; //실제 최고입찰가
  double posted_price; //현재 시장가
  start_message s_mess;
  bidding_message b_mess;
  result_message r_mess;

  public Auction_Customer() {
//this("Auction_Customer",20);
  }

  public Auction_Customer(String name, int n, double m, double p) {
    super(name);
    addInport("pricein"); //result_messge
    addOutport("bidout"); //bidding_message
    addInport("in"); //start_message
    num = n;
    MBP = m;
    PE = p;
  }

  public void initialize() {
    phase = "passive";
    sigma = INFINITY;
    job = new entity("job");
    s_mess = new start_message("START", 0, 0);
    b_mess = new bidding_message("BIDDING", 0, 0);
    r_mess = new result_message("RESULT", "end", "", 0);
    super.initialize();
  }

  public void deltext(double e, message x) {
    Continue(e);

    if (phaseIs("passive")) {
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "in", i)) {
          job = x.getValOnPort("in", i);
          s_mess = (start_message) job;
          //System.out.println("In Port로 Auctioneer로부터 start 메시지 받음");
          real_MBP = s_mess.initial_price * MBP; //실제입찰한도
          bid_price = s_mess.initial_price + (int) (Math.random() * PE); //첫번째 입찰가
          holdIn("busy", 0);
        }
      }
      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "pricein", i)) {
          job = x.getValOnPort("pricein", i);
          r_mess = (result_message) job;
          //System.out.println("pricein Port로 Auctioneer로부터 result 메시지 받음");
          posted_price = r_mess.highest_price;
          if (r_mess.status == "progree") {
            if (posted_price < real_MBP) {
              bid_price = posted_price + (int) (Math.random() * PE);
            }
            else {
              bid_price = 0;
            }
          }
          else {
            bid_price = 0;
          }
          holdIn("busy", 0);
        }
      }
    }
  }

  public void deltint() {
    passivate();
    job = new entity("none");
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();
    if (phaseIs("busy")) {
      m.add(makeContent("bidout", new bidding_message("BIDDING", num, bid_price)));
    }
    //System.out.println("Bidout Port로 Auctioneer에게 bidding 메시지 보냄");
    return m;
  }

  public void showState() {
    super.showState();
//    System.out.println("job: " + job.getName());
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

// start_message.java
// modifued by Aettie Ji
// April 21st, 2009
package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class start_message
    extends entity {
  public double product_num; // 상품 번호
  public double initial_price; // 초기 가격

  public start_message(String name, double num, double ip) {
    super(name);
    product_num = num;
    initial_price = ip;
  }
}

// bidding_message.java
// modifued by Aettie Ji
// April 21st, 2009
package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class bidding_message
    extends entity {
  public int customer_num; //입찰자정보
  public double bidding_price; //입찰가격

  public bidding_message(String name, int num, double bp) {
    super(name);
    customer_num = num;
    bidding_price = bp;
  }
}

// result_message.java
// modifued by Aettie Ji
// April 21st, 2009
package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class result_message
    extends entity {
  public String status; // 경매진행상태
  public String highest_bidder; // 최고 입찰자
  public double highest_price; // 최고 가격

  public result_message(String name, String s, String hb, double hp) {
    super(name);
    status = s;
    highest_bidder = hb;
    highest_price = hp;
  }
}

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

이번 시간엔 Minimum Load First Scheduling Model을 맹글어보았다.
말그대로, 지난 시간의 Round Robin Scheduling처럼 생성되는 job을 순서대로 processor에 한개씩 한개씩 보내는 것과는 달리
5개의 프로세서 중 현재 가장 적은 Workload를 가진 processor에게 job을 주겠다는 뜻이다.

그렇다면 Round Robin Scheduling에서 변경되어야 할 몇 가지를 살펴보면,

1. Scheduler가 workload를 계산할 수 있도록 하기 위해 필요한 값을 입력받을 port와 이 필요값을 저장할 공간이 필요하다.
   • Scheduler의 in port는 Generator로 부터 job을 받을 1개의 port와,
   • 각 5개의 Processor로 부터 job이 solved되었다는 정보를 받을 5개의 port로 총 6개가 필요하다.
   • 다음과 같은 배열을 만든다.

     Processor Number	Workload
     0	0
     1	0
     2	0
     3	0
     4	0

   • 해당 번호의 Processor로 job이 할당되면 Workload 1증가 (이 때 processor의 queue 크기인 10을 넘을 수 없다.)
   • 해당 번호의 Processor로부터 solved message를 받으면 Workload 1감소


2. 가장 Workload가 적은 processor를 계산하는 부분이 필요하다.
   • Bubble Sort를 사용하는데, sorting방법은 어떤 것을 사용해도 관계없다.
   • 현재 상태에서 가장 workload가 적은 processor에 job을 할당한다.


3. 모든 5개의 processor의 processing time이 같다면, workload를 계산하는 의미가 없다. (어차피 순서대로일 테니깐...) 그래서 각 processor의 processing time을 다르게 할당해준다.
   • Processor 0 = 10
   • Processor 1 = 15
   • Processor 2 = 20
   • Processor 3 = 15
   • Processor 4 = 25

다이어그램은 요렇다.

다음은 소스 코드...

// mlfsm.java
// modified by Aettie Ji
// April, 7 2009

package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class mlfsm
    extends ViewableDigraph {
  int processor_num = 5;
  int queue_size = 10;
  int processingT[]; // 프로세싱 타임을 저장할 배열
  int int_arr_time = 5;
  int observation_time = 1000;

  public mlfsm() {
    super("mlfsm");
    processingT = new int[processor_num]; //프로세싱 타임을 저장할 배열
    processingT[0] = 10;
    processingT[1] = 15;
    processingT[2] = 20;
    processingT[3] = 15;
    processingT[4] = 25;

    ViewableAtomic g = new genr("GENERATOR", int_arr_time);
    ViewableAtomic t = new transducer("TRANSDUCER", observation_time,
                                      processor_num);
    ViewableAtomic s = new schedulerM("SCHEDULER_M", processor_num);

    add(g);
    add(t);
    add(s);
    //coupling 추가
    for (int i = 0; i < processor_num; i++) {
      ViewableAtomic p = new processor("PROCESSOR" + i, i, processingT[i],
                                       queue_size); // 배열에 저장된 processing time을 각각 할당
      add(p);
      addCoupling(s, "out" + i, p, "in");
      addCoupling(p, "out1", t, "solved");
      addCoupling(p, "out1", s, "in" + i);
      addCoupling(p, "out2", t, "in" + i);
    }

    addInport("in");
    addInport("start");
    addInport("stop");
    addOutport("out");
    addOutport("result");

    addCoupling(this, "in", g, "in");
    addCoupling(this, "start", g, "start");
    addCoupling(this, "stop", g, "stop");
    addCoupling(g, "out", s, "in");
    addCoupling(g, "out", t, "ariv");
    addCoupling(t, "out", g, "stop");
    addCoupling(t, "out", this, "result");

//    initialize();
    showState();
    /*
      preferredSize = new Dimension(484, 145);
      g.setPreferredLocation(new Point(13, 18));
      p.setPreferredLocation(new Point(195, 18));
      t.setPreferredLocation(new Point(193, 80));
     */
  }

  /**
   * Automatically generated by the SimView program.
   * Do not edit this manually, as such changes will get overwritten.
   */
  public void layoutForSimView() {
    preferredSize = new Dimension(985, 409);
    ( (ViewableComponent) withName("SCHEDULER")).setPreferredLocation(new Point(
        135, 22));
    ( (ViewableComponent) withName("GENERATOR")).setPreferredLocation(new Point(
        11, 171));
    ( (ViewableComponent) withName("PROCESSOR3")).setPreferredLocation(new
        Point(376, 246));
    ( (ViewableComponent) withName("PROCESSOR0")).setPreferredLocation(new
        Point(366, 7));
    ( (ViewableComponent) withName("PROCESSOR2")).setPreferredLocation(new
        Point(369, 181));
    ( (ViewableComponent) withName("TRANSDUCER")).setPreferredLocation(new
        Point(645, 147));
    ( (ViewableComponent) withName("PROCESSOR1")).setPreferredLocation(new
        Point(374, 92));
    ( (ViewableComponent) withName("PROCESSOR4")).setPreferredLocation(new
        Point(377, 313));
  }
}

// schedulerM.java
// modified by Aettie Ji
// April, 7 2009

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;

public class schedulerM
    extends ViewableAtomic { //ViewableAtomic is used instead
  //of atomic due to its
  //graphics capability
  protected entity job;
  protected double processing_time;
  int processor_num; //프로세서 갯수
  int out_port_num; //작업 보낼 아웃 포트
  int workload_list[][]; //work load save
  int temp_list[][]; //list for sorting

  public schedulerM() {
    this("schedulerM", 20);
  }

  public schedulerM(String name, int num) {
    super(name);
    processor_num = num;

    addInport("in");
    for (int i = 0; i < processor_num; i++) {
      addInport("in" + i); //프로세서 갯수만큰 inport 생성
      addOutport("out" + i); //프로세서 갯수만큰 outport 생성
    }
    processing_time = 0;
  }

  public void initialize() {
    phase = "passive";
    sigma = INFINITY;
    job = new entity("job");
    out_port_num = 0;
    workload_list = new int[5][2];
    temp_list = new int[5][2];
    for (int i = 0; i < 5; i++) {
      workload_list[i][0] = i; //processor num
      workload_list[i][1] = 0; //processor workload
      temp_list[i][0] = i;
      temp_list[i][1] = 0;
    }
    super.initialize();
  }

  public void deltext(double e, message x) {
    Continue(e);

    if (phaseIs("passive")) {
      //이중 for문을 이용하여 각 프로세서와 연결된 포트로부터 메시지 수신
      for (int j = 0; j < processor_num; j++) {
        for (int i = 0; i < x.size(); i++) {
          if (messageOnPort(x, "in" + j, i)) {
            job = x.getValOnPort("in" + j, i); //in+j로 들어온 메세지를 val에 저장
            workload_list[j][1]--; //포트로부터 완료작업이 들어오면 해당 프로세서의 작업로드 1 감소
          }
        }
      }

      for (int i = 0; i < x.getLength(); i++) {
        if (messageOnPort(x, "in", i)) {
          job = x.getValOnPort("in", i);
          for (int k = 0; k < processor_num; k++) {
            temp_list[k][0] = workload_list[k][0]; //프로세서 번호 복사
            temp_list[k][1] = workload_list[k][1]; //workload 복사
            System.out.println("Processor " + k + " 의 workload :" +
                               workload_list[k][1]);
          }
          int temp1 = 0; //temp variable 1
          int temp2 = 0; //temp variable 2
          //bubble sort
          for (int a = 0; a < processor_num - 1; a++) {
            for (int b = a + 1; b < processor_num; b++) {
              if (temp_list[a][1] > temp_list[b][1]) {
                temp1 = temp_list[a][0];
                temp_list[a][0] = temp_list[b][0];
                temp_list[b][0] = temp1;
                temp2 = temp_list[a][1];
                temp_list[a][1] = temp_list[b][1];
                temp_list[b][1] = temp2;
              }
            }
          }
          out_port_num = temp_list[0][0]; //작업 부하가 가장 작은 processor
          if (workload_list[out_port_num][1] < 10) {
            workload_list[out_port_num][1]++; //지금 할당받은 processor 작업부하 1 증가
          }
          holdIn("busy", processing_time);
        }
      }
    }
  }

  public void deltint() {
    passivate();
    job = new entity("none");
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();
    if (phaseIs("busy")) {
      m.add(makeContent("out" + out_port_num, job));
    }
    return m;
  }

  public void showState() {
    super.showState();
    System.out.println("job: " + job.getName());
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

이제 마지막으로 지난시간의 rrsm와 비교실험을 할텐데,
조건을 같게 해주기 위해 위의 mlfsm과 같이 5개 processor의 processing time을 다르게 설정하였다.
소스는 그 부분만 다르지만 참고를 위해 rrsm과 이 scheduler소스코드로 같이 올린다.
(사실은 지난 번 포스트를 찾아가서 보기 귀찮다으...)
Generator와 Processro, Transducer는 완전히 같은 것을 사용하기 때문에 생략...

// rrsmCompare.java
// modified by Aettie Ji
// April, 7 2009

package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class rrsmCompare
    extends ViewableDigraph {
  int processor_num = 5;
  int queue_size = 10;
  int processingT[]; //프로세싱 타임을 저장할 배열
  int int_arr_time = 5;
  int observation_time = 1000;

  public rrsmCompare() {
    super("rrsmCompare");
    processingT = new int[processor_num]; //프로세싱 타임을 저장할 배열
    processingT[0] = 10;
    processingT[1] = 15;
    processingT[2] = 20;
    processingT[3] = 15;
    processingT[4] = 25;

    ViewableAtomic g = new genr("GENERATOR", int_arr_time);
    ViewableAtomic t = new transducer("TRANSDUCER", observation_time, processor_num);
    ViewableAtomic s = new scheduler("SCHEDULER", processor_num);

    add(g);
    add(t);
    add(s);
    //coupling 추가

    for (int i = 0; i < processor_num; i++) {
      ViewableAtomic p = new processor("PROCESSOR" + i, i, processingT[i],
                                       queue_size); // 배열에 저장된 processing time을 각각 할당
      add(p); 
      addCoupling(s, "out" + i, p, "in");
      addCoupling(p, "out1", t, "solved");
      addCoupling(p, "out2", t, "in" + i);

    }

    addInport("in");
    addInport("start");
    addInport("stop");
    addOutport("out");
    addOutport("result");

    addCoupling(this, "in", g, "in");
    addCoupling(this, "start", g, "start");
    addCoupling(this, "stop", g, "stop");
    addCoupling(g, "out", s, "in");
    addCoupling(g, "out", t, "ariv");
    addCoupling(t, "out", g, "stop");
    addCoupling(t, "out", this, "result");

//    initialize();
    showState();
    /*
     preferredSize = new Dimension(484, 145);
     g.setPreferredLocation(new Point(13, 18));
     p.setPreferredLocation(new Point(195, 18));
     t.setPreferredLocation(new Point(193, 80));
     */
  }

  /**
   * Automatically generated by the SimView program.
   * Do not edit this manually, as such changes will get overwritten.
   */
  public void layoutForSimView() {
    preferredSize = new Dimension(985, 409);
    ( (ViewableComponent) withName("GENERATOR")).setPreferredLocation(new Point(
        11, 171));
    ( (ViewableComponent) withName("PROCESSOR3")).setPreferredLocation(new
        Point(376, 246));
    ( (ViewableComponent) withName("PROCESSOR1")).setPreferredLocation(new
        Point(374, 92));
    ( (ViewableComponent) withName("PROCESSOR4")).setPreferredLocation(new
        Point(377, 313));
    ( (ViewableComponent) withName("PROCESSOR0")).setPreferredLocation(new
        Point(366, 7));
    ( (ViewableComponent) withName("TRANSDUCER")).setPreferredLocation(new
        Point(645, 147));
    ( (ViewableComponent) withName("PROCESSOR2")).setPreferredLocation(new
        Point(369, 181));
    ( (ViewableComponent) withName("SCHEDULER")).setPreferredLocation(new Point(
        133, 70));
  }
}

// scheduler.java
// modified by Aettie Ji
// April, 7 2009

package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;

public class scheduler
    extends ViewableAtomic { //ViewableAtomic is used instead
  //of atomic due to its
  //graphics capability
  protected entity job;
  protected double processing_time;
  int processor_num; //프로세서 갯수
  int out_port_num; //작업 보낼 아웃 포트

  public scheduler() {
    this("scheduler", 20);
  }

  public scheduler(String name, int num) {
    super(name);
    processor_num = num;

    addInport("in");
    for (int i = 0; i < processor_num; i++) { //프로세서 갯수만큰 아웃포트 생성
      addOutport("out" + i);
    }
    //which should cause only "continue"
    processing_time = 0;
  }

  public void initialize() {
    phase = "passive";
    sigma = INFINITY;
    job = new entity("job");
    out_port_num = 0;
    super.initialize();
  }

  public void deltext(double e, message x) {
    Continue(e);

    if (phaseIs("passive"))
      for (int i = 0; i < x.getLength(); i++)
        if (messageOnPort(x, "in", i)) {
          job = x.getValOnPort("in", i);
          holdIn("busy", processing_time);
        }
  }

  public void deltint() {
    passivate();
    job = new entity("none");
  }

  public void deltcon(double e, message x) {
    deltint();
    deltext(0, x);
  }

  public message out() {
    message m = new message();
    if (phaseIs("busy")) {
      m.add(makeContent("out" + out_port_num, job)); //out0~4까지 job 객체를 송신
    }
//라운드 로빈 스케줄링
    out_port_num++; //out port가 5 이상이 되는 경우, 존재하지 않는 out port이므로 0으로
    if (out_port_num > (processor_num - 1))
//if(out_port_num>=processor_num)
    {
      out_port_num = 0;
    }
    return m;
  }

  public void showState() {
    super.showState();
    System.out.println("job: " + job.getName());
  }

  public String getTooltipText() {
    return
        super.getTooltipText()
        + "\n" + "job: " + job.getName();
  }
}

실험은 int_arr_time을 1부터 5로 증가시키면서 두 개의 모델을 비교하는 것이다.
observation time은 1000이다.

Int_arr_time	Job Loss Rate		Throughput		AVG_TA
	MLFSM	RRSM	MLFSM	RRSM	MLFSM	RRSM
1	0.625	0.622	0.319	0.319	137.66	137.57
2	0.259	0.277	0.319	0.319	124.00	102.82
3	0.0	0.075	0.317	0.285	32.93	56.33
4	0.0	0.004	0.245	0.236	14.79	32.33
5	0.0	0.0	0.196	0.195	13.70	16.92

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

네 번째 시간에는 Round Robin Scheduling Model을 만들었다아...
스케줄러를 만들고 이 녀석이 여러 개의 프로세서에 순차적으로 job을 보내주는 역할을 하는 거다.
각 프로세서는 queue로 되어 있어서, scheduler로 부터 받은 job을 차곡차곡 넣어놓고 처리하다가
queue 크기를 초과하게 되면 job loss가 발생한다.

각 모델이 하는 일과 변수를 좀 더 자세히 설명한 것이다...

1. Generator (Atomic Model)
• Generates a job every int_arr_time and send it to Scheduler.
• Variables : int_arr_time(int), job_count(int)
2. Scheduler (Atomic Model)
• Determines the order for job allocation and allocates jobs to Processors in regular sequence. (If there are 3 processors in the RRSM, the order is P1→ P2→ P3→ P1→ P2→ P3…)
• Variables : number_of_processor(int), outport_num(int)
3. Processor (Atomic Model)
• Process jobs and send them to Transducer
• Variables : queue_size(int), job_loss(int), queue_count(int), processing_time(int)
※ Notice that Processor has a queue (size =10) to store jobs temporarily when the jobs are inputted to the processor with the "Busy" state. If a new job is inputted when the queue is full (number of stored jobs ≥ 10), the job will be lost and job_loss increases by 1. The processor sends out a solved job and a job_loss message through the "out1" port and the "out2" port.
4. Transducer (Atomic Model)
• Calculates Job loss rate, Throughput, and Average turn around time
• Variables : observation_time(int), total_jobLoss(int), jobLoss(int [number of processors])
※ Notice that you have to make a new function to calculate job loss rate (the number of lost jobs / the number of generated jobs). Functions for Throughput and Average turn around time are provided by transd.java. And, loss messages from processors are inputted to some input ports (in0~in n).

우리가 만들어야 하는 파일은 다섯개이다.

1. Make the rrsm.java, which is modified from the gpt.java file. Notice that the number of processors is 5. Please refer to the above figure for the composition of the round robin scheduling model
2. Make the loss_message.java, which is modified from the job.java file. Loss_message includes the processor number and its job loss count.
3. Make the scheduler.java, which is modified from the proc.java.
4. Make the processor.java, which is modified from the procQ.java. But, the queue of processor has the fixed size of 10.
5. Make the transducer.java, which is modified from the transd.java. Add a new function for the calculation of job loss rate to transducer.

그럼 하나씩 맹글어 봐야지,

사실 generator는 변한 게 없다...ㅋㅋㅋ

// generatorRrsm.java
// Round robin scheduler model
// modified by Aettie Ji
// April, 1. 2009
package SimpArc;

import simView.*;

import java.lang.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class generatorRrsm extends ViewableAtomic{

	protected double int_arr_time;
	protected int count;

	public generatorRrsm() {this("generator", 30);}

	public generatorRrsm(String name,double Int_arr_time){
		super(name);
		addInport("in");
		addOutport("out");
		addInport("stop");
		addInport("start");
		int_arr_time = Int_arr_time ;
	}

	public void initialize(){
		holdIn("active", int_arr_time);
	//  phase = "passive";
	//  sigma = INFINITY;
		count = 0;
		super.initialize();
	}
	public void  deltext(double e,message x)
	{
		Continue(e);
		if(phaseIs("passive")){
			for (int i=0; i< x.getLength();i++)
				if (messageOnPort(x,"start",i))
					holdIn("active",int_arr_time);
		}
		if(phaseIs("active")){
			for (int i=0; i< x.getLength();i++)
				if (messageOnPort(x,"stop",i))
					phase = "finishing";
		}
	}
	public void  deltint( )
	{
		if(phaseIs("active")){
			count = count +1;
			holdIn("active",int_arr_time);
		}
		else passivate();
	}
	public message  out( )
	{
		message  m = new message();
		content con = makeContent("out", new entity("job" + count));
		m.add(con);

		return m;
	}
	public void showState(){
		super.showState();
		System.out.println("int_arr_t: " + int_arr_time);
	}
	public String getTooltipText(){
		return
		super.getTooltipText()
			+"\n"+" int_arr_time: " + int_arr_time
			+"\n"+" count: " + count;
	}
}

generator에서 생성한 job을 processor에 순서대로 분배하는 일을 하는 scheduler에서는
processor의 갯수만큼 outport를 만들어 줘야 하고,
이 해당 outport에서 메시지가 out되는 부분에서 스케줄링 해준다.
즉, out() method에서 해주게 되는데, 아주 간단하게 message를 하나 내보낼 때마다 outport number를 하나씩 증가시키고,
이 숫자가 processor의 갯수를 넘어가면, outport number를 다시 0으로 셋팅하면 된다.
그러면 job이 processor의 순서대로 전달되게 된다.

// scheduler.java
// Round robin scheduler model
// modified by Aettie Ji
// April, 1. 2009
package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;
import simView.*;

public class scheduler extends ViewableAtomic{
    protected entity job;
    protected double processing_time;
    int processor_num; //프로세서 갯수
    int out_port_num; //작업 보낼 아웃 포트

	public scheduler(){
	this("scheduler",20);
	}

	public scheduler(String  name, int num){
		super(name);
		processor_num = num;
		addInport("in");
		for(int i = 0; i < processor_num; i++)//프로세서 갯수만큰 아웃포트 생성
		{
			addOutport("out"+i);
		}
		processing_time = 0;
	}

	public void initialize(){
		phase = "passive";
		sigma = INFINITY;
		job = new entity("job");
		out_port_num = 0; // out_port_num 초기화
		super.initialize();
	}
 
	public void  deltext(double e,message   x)
	{
		Continue(e);
		if (phaseIs("passive")){
			for (int i=0; i< x.getLength();i++){
				if (messageOnPort(x,"in",i))
				{
					job = x.getValOnPort("in",i);
					holdIn("busy",processing_time);
				}
			}
		}
	}

	public void  deltint( )
	{
		passivate();
		job = new entity("none");
	}

	public void deltcon(double e,message x)
	{
		deltint();
		deltext(0,x);
	}

	public message    out( )
	{
		message   m = new message();
		if (phaseIs("busy")) {
			m.add(makeContent("out"+out_port_num,job));//out0~4까지 job 객체를 송신
		}
		//라운드 로빈 스케줄링
		out_port_num++;//out port가 4 이상이 되는 경우, 존재하지 않는 out port이므로 0으로
		if(out_port_num>(processor_num-1)) // processor_num - 1
		{
			out_port_num = 0;
		}
		return m;
	}

	public void showState()
	{
		super.showState();
		System.out.println("job: " + job.getName());
	}

	public String getTooltipText(){
		return
		super.getTooltipText()+"\n"+"job: " + job.getName();
	}
}

각 processor가 하는 일은 in port로 들어온 job을 처리하고 만약 queue가 다 찼는데도 job이 들어오면
이를 loss로 간주하고, loss 발생시마다 job_loss 변수를 증가시키고 이를 job loss message에 포함시켜 transducer에 전달한다.
때문에 out port는 두 개가 되는데, out1은 solved job이, out2는 loss message가 나가는 port이다.

// processor.java
// Round robin scheduler model
// modified by Aettie Ji
// April, 1. 2009
package SimpArc;

import simView.*;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class processor extends proc{
	protected Queue q;	
	int pNum;//프로세서 번호	
	int queue_size;//큐사이즈	
	int job_loss;//작업손실갯수

	public processor(String  name,int n,double  Processing_time, int qz){
		super(name,Processing_time);
		q = new Queue();		
		pNum = n;//프로세서 번호
		queue_size = qz;//큐 사이즈 입력
		addOutport("out1");//아웃포트2개생성
		addOutport("out2");
	}

	public processor(){
		super("procQ",20);
		initialize();
	}

	public void initialize(){
		q = new Queue();
		super.initialize();
	}
 
	public void  deltext(double e, message   x){
		Continue(e);
		if (phaseIs("passive")){
			for (int i=0; i< x.size(); i++){
				if (messageOnPort(x, "in", i)){
					job = x.getValOnPort("in", i);
					holdIn("busy", processing_time);
					q.add(job);
				}
			}
		    job = (entity)q.first();  // this makes sure the processed job is the one at
                  //the front
		}	 
		else if (phaseIs("busy")){
			for (int i=0; i< x.size();i++){
				if (messageOnPort(x, "in", i)){
					entity jb = x.getValOnPort("in", i);
					if (q.size() < queue_size){
						q.add(jb);
					}
					else {
						job_loss++; //작업손실 발생하면 더해준다.
						//System.out.println("JOB LOSS COUNT: "+job_loss);
					}
				}
			}
		}
	}

	public void  deltint( ){
		q.remove();
		if(!q.isEmpty()){
			job = (entity)q.first();
			holdIn("busy", processing_time);
		}
		else passivate();
	}

	public message    out( ){
		message   m = new message();
		if (phaseIs("busy")) {
			m.add(makeContent("out1",job));//완료작업 전달
			//작업손실정보전달
			m.add(makeContent("out2", new loss_message("message",getName(),job_loss, pNum)));
		}
		//System.out.println("JOB LOSS COUNT: "+job_loss);
		return m;
	}

	public void showState(){
		super.showState();
		System.out.println("Queue length: " + q.size());
	}

	public String getTooltipText(){
		return
			super.getTooltipText()
			+"\n"+"queue length: " + q.size()
			+"\n"+"queue itself: " + q.toString();
	}
}

processor에서 loss_message라는 객체를 생성하여 보내는 것을 볼 수 있는데
loss_message객체는 간단하다..ㅋㅋ

해당 processor의 이름, 번호, job loss count만을 포함할 수 있도록 만든다.

// loss_message.java
// Round robin scheduler model
// modified by Aettie Ji
// April, 1. 2009
package SimpArc;

import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class loss_message extends entity{
     public String process_name; 
     public int process_num; // processor number
     public int job_loss; // job_loss의 갯수 전달

	public loss_message(String name){
		super(name);
	}

	public loss_message(String name,String pName, int jl, int pNum){
		super(name);
		process_name = pName;
		process_num = pNum;
		job_loss = jl;
	}
}

transducer는 여러가지 측정치를 계산해 주는데, turn around time(compute_TA())
throughput(compute_Thru())을 계산해 주는 함수는 이미 구현되어 있고,
여기에다가 job loss를 계산하는 compute_JobLoss() 함수를 만들어준다.
transducer는 계산을 위해서 여러 개의 port로 값을 받는데,
ariv port로는 generator에서 생성된 job 메시지를, solved port로는 processor로부터 처리된 job을 받게 된다.
우리는 5개의 processor를 만들었으므로, 5개의 processor out port로 부터 각각 solved와 loss 메시지를 받아야 한다.

processor의 out1 port는 처리된 job을 transducer의 solved로 보내고,
out2 port는 transducer의 5개의 in port로 각각 loss메시지를 보낸다.
job loss 저장을 위해서 배열을 만들어 모두 더한 값을 generator에서 생성된 전체 job 갯수로 나누면
job loss rate을 계산할 수 있다.

이전과 다르게 추가된 부분은, processor에 job이 남아있더라도, observation time이 되면 system이 종료되도록 했다.

// transducer.java
// Round robin scheduler model
// modified by Aettie Ji
// April, 1. 2009
package SimpArc;

import simView.*;

import java.lang.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class transducer extends  ViewableAtomic{
	protected Function  arrived, solved;
	protected double clock,total_ta,observation_time;
	int processor_num;
	int loss[]; //각 프로세서의 작업손실 갯수 
	loss_message message;

	public transducer(String  name,double Observation_time, int num){
		super(name);
		processor_num = num;
		for(int i = 0; i < processor_num; i++){
			addInport("in"+i);
		}
		addOutport("out");
		addInport("ariv");
		addInport("solved");
  
		arrived = new Function();
		solved = new Function();
		observation_time = Observation_time;
		entity test = new entity("val");
		addTestInput("ariv",test);
		addTestInput("solved",test,10);
	}

	public transducer()
	{
		this("transd", 200,5);
	}

	public void initialize(){
		phase = "active";
		sigma = observation_time;
		clock = 0;
		total_ta = 0;
		loss = new int[processor_num];
		message = new loss_message("message");//객체 초기화
		arrived = new Function();
		solved = new Function();
		for (int i=0; i < processor_num; i++){ //배열 초기화
			loss[i] = 0;
		}
	}

	public void showState(){
		super.showState();
		System.out.println("arrived: " + arrived.size());
		System.out.println("solved: " + solved.size());
		System.out.println("TA: "+compute_TA());
		System.out.println("Thruput: "+compute_Thru());
	}

	public void  deltext(double e,message  x){
		clock = clock + e;
		Continue(e);
		entity  val;
		//이중 for문을 이용하여 각 포트별로 메시지 수신
		for (int j = 0; j < processor_num; j++){
			for (int i = 0; i < x.size(); i++) {
				if (messageOnPort(x, "in"+j, i)) {
					val = x.getValOnPort("in"+j, i);//in+j로 들어온 메세지를 val에 저장
					message = (loss_message)val;//입력받은 객체를 loss_message타입으로 형변환
					loss[j] = message.job_loss;//작업 손실정보저장
					//System.out.println("JOB LOSS COUNT: "+message.job_loss);
				}
			}
		}
		for(int i=0; i< x.size();i++){
			if(messageOnPort(x,"ariv",i)){
				val = x.getValOnPort("ariv",i);
				arrived.put(val.getName(),new doubleEnt(clock));
			}
			if(messageOnPort(x,"solved",i)){
				val = x.getValOnPort("solved",i);
				if(arrived.containsKey(val.getName())){
					entity  ent = (entity)arrived.assoc(val.getName());
					doubleEnt  num = (doubleEnt)ent;
					double arrival_time = num.getv();
					double turn_around_time = clock - arrival_time;
					total_ta = total_ta + turn_around_time;
					solved.put(val, new doubleEnt(clock));
				}
			}
		}
		show_state();
	}

	public void  deltint(){
		clock = clock + sigma;
		passivate();
		show_state();
	}

	public  message    out( ){
		message  m = new message();
		content  con = makeContent("out",new entity("TA: "+compute_TA()));
		m.add(con);
		return m;
	}

	public double compute_JobLoss(){
		int total_job_loss = 0;//총 작업 손실 갯수
		double job_loss_rate = 0; //작업 손실률
		for(int i=0; i < processor_num; i++){
			total_job_loss += loss[i];
			// System.out.println("LOSS[i]: " +loss[i]);
		}
		job_loss_rate = ((double)total_job_loss)/arrived.size();
		// System.out.println("TOTAL JOB LOSS COUNT: " + total_job_loss);
		// System.out.println("ARRIVED SIZE: " + arrived.size());
		// System.out.println("JOB_LOSS_RATE: " + job_loss_rate);
		return job_loss_rate;
	}

	public double compute_TA(){
		double avg_ta_time = 0;
		if(!solved.isEmpty())
			avg_ta_time = ((double)total_ta)/solved.size();
		return avg_ta_time;
	}

	public double compute_Thru(){
		double thruput = 0;
		if(clock > 0)
			thruput = solved.size()/(double)clock;
		return thruput;
	}

	public void  show_state(){
		System.out.println("state of  "  +  name  +  ": " );
		System.out.println("phase, sigma : "
			  + phase  +  " "  +  sigma  +  " "   );
		if (arrived != null && solved != null){
			System.out.println(" jobs arrived :" );
	//      arrived.print_all();;
			System.out.println("total :"  +  arrived.size()  );
			System.out.println("jobs solved :" );
	//      solved.print_all();
			System.out.println("total :"  +  solved.size()  );
			System.out.println("AVG TA = "  +  compute_TA()   );
			System.out.println("THRUPUT = "  +  compute_Thru()  );
			System.out.println("JOB LOSS = "  +  compute_JobLoss()  );
		}
		if (clock == observation_time){
				System.exit(0); //clock == observation_time 이면 종료
		}
	}

	public String getTooltipText(){
		String  s = "";
		if (arrived != null && solved != null){
			s = "\n"+"jobs arrived :"   +  arrived.size()
				+"\n"+"jobs solved :"  +  solved.size()
				+"\n" + "AVG TA = "  +  compute_TA()
				+"\n" + "THRUPUT = "  +  compute_Thru();
		}
		return super.getTooltipText()+s;
	}
}

마지막으로 Round Robin Scheduler Model을 만들어 준다.
각 atomic model을 추가하고, processor만 5개를 만들어주며, 그에 맞는 port끼리 coupling해 준다.

// rrsm.java
// Round robin scheduler model
// modified by Aettie Ji
// April, 1. 2009

package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class rrsm extends ViewableDigraph{
	int processor_num = 5;
	int queue_size = 10;

	public rrsm(){
		super("rrsm");

	    ViewableAtomic g = new generatorRrsm("GENERATOR",20);
	    ViewableAtomic t = new transducer("TRANSDUCER",1000, processor_num);
		ViewableAtomic s = new scheduler("SCHEDULER", processor_num);

		add(g);
	    add(t);
		add(s);

		// processor 수를 5개로 하여 생성하고, 각 processor의 port와 적절한 port를 coupling
		for (int i = 0; i < processor_num; i++){
			ViewableAtomic p = new processor("PROCESSOR"+i,i,50, queue_size);
			add(p);
			addCoupling(s,"out"+i,p,"in");
			addCoupling(p,"out1",t,"solved");
			addCoupling(p,"out2",t,"in"+i);
		}
		// rrsm diagraph model에 port 추가
		addInport("in");
		addInport("start");
		addInport("stop");
		addOutport("out");
		addOutport("result");
		// rrsm diagraph model에 coupling 추가
		addCoupling(this,"in",g,"in");
		addCoupling(this,"start",g,"start");
		addCoupling(this,"stop",g,"stop");
		addCoupling(g,"out",s,"in");
		addCoupling(g,"out",t,"ariv");
		addCoupling(t,"out",g,"stop");
		addCoupling(t,"out",this,"result");

		showState();
	}
    /**
     * Automatically generated by the SimView program.
     * Do not edit this manually, as such changes will get overwritten.
     */
    public void layoutForSimView()
    {
        preferredSize = new Dimension(985, 409);
        ((ViewableComponent)withName("GENERATOR")).setPreferredLocation(new Point(11, 171));
        ((ViewableComponent)withName("PROCESSOR3")).setPreferredLocation(new Point(376, 246));
        ((ViewableComponent)withName("PROCESSOR1")).setPreferredLocation(new Point(374, 92));
        ((ViewableComponent)withName("PROCESSOR4")).setPreferredLocation(new Point(377, 313));
        ((ViewableComponent)withName("PROCESSOR0")).setPreferredLocation(new Point(366, 7));
        ((ViewableComponent)withName("TRANSDUCER")).setPreferredLocation(new Point(645, 147));
        ((ViewableComponent)withName("PROCESSOR2")).setPreferredLocation(new Point(369, 181));
        ((ViewableComponent)withName("SCHEDULER")).setPreferredLocation(new Point(133, 70));
    }
}

헥헥...힘들다...
마지막으로...실험...ㅜ_ㅜ
generator의 int_arr_time을 5부터 20까지 5씩 증가시키고,
processor의 processing time을 10에서 50까지 10씩 증가시키면서
job loss, throughput, average turn around time을 비교한다.
transducer의 abservation time은 1000이다.

JOB LOSS

Int_arr_time/Processing time	5	10	15	20
10	0.0	0.0	0.0	0.0
20	0.0	0.0	0.0	0.0
30	0.0	0.0	0.0	0.0
40	0.1507	0.0	0.0	0.0
50	0.2516	0.0	0.0	0.0

THROUGHPUT

Int_arr_time/Processing time	5	10	15	20
10	0.197	0.098	0.065	0.049
20	0.195	0.097	0.065	0.048
30	0.161	0.096	0.064	0.048
40	0.12	0.095	0.063	0.047
50	0.095	0.094	0.063	0.047

AVERAGE TRUNAROUND TIME

Int_arr_time/Processing time	5	10	15	20
10	10.0	10.0	10.0	10.0
20	20.0	20.0	20.0	20.0
30	108.01	30.0	30.0	30.0
40	212.5	40.0	40.0	40.0
50	275.0	50.0	50.0	50.0

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

벌써 4주나 강의가 진행되었고, 오늘 바로 그 4주째 강의의 실험을 해야 하기땜시
내친 김에 모조리 포스팅 해버려야겠다.
어차피 복습도 좀 필요하고 말야...

세 번째 시간은 아주 간단한 걸 했다...
(그치만 4주째는 완전 초토화였다는거...ㅜ_ㅜ)


요 모델은 지난 포스팅에 익히 보았던 gpt 모델이지만, 한 가지 다른 점이 있다.
세 개의 atomic model을 사용한 것이 아니라, EF라는 diagraph model을 사용한 것이다.
요 EF는 generator와 transducer를 합쳐놓은 것이다.
뭐 조금 단정한 느낌이 드나?
generator와 transducer 간에 서로 전달되어야 하는 메시지가 많으니 합치는 것이 더 좋을지도...


세 번째 시간에 할 일은...

1. Make the gtp3.java, which is modified from the gpt.java file. The GPT3 model includes a digraph model and a queue processor. The diagraph model is called the EF model which consists of a generator and a transducer. The generator and the queue processor can be referred from figures below. Expect and draw the trajectory of the transducer. Compare the simulation result of the GPT3 model. Note that the queue processor has 30 processing time and the Transducer has 200 observation time, and the generation time of the generator is repeatedly changed (15↔30, initial generation time = 15).
2. What is the total turn_arround_time?
3. What is the average of turn_arround_time?
4. What is the throughput?

EF 모델을 사용한 gpt3을 만들고,
generator의 시간은 15 <->30으로 교환되고,
queue processor의 processing time은 30
transducer의 observation time은 200이다.

위 조건으로 만든 gpt3.java파일이다.

/* gpt3.java */
/* modified by Aettie Ji*/
/* March, 23. 2009 */

package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class gpt3 extends ViewableDigraph{

public gpt3(){
    super("gpt3");
    
	//Diagraph model EF, initiall int_ariv_t = 15, ovservation time = 200 
    ViewableDigraph e = new ef1("EF",15,200);
    //Atomic model Queue processor p, processing time = 30
	ViewableAtomic p = new procQ("p",30); 

     add(p);
     add(e);

	 //Coupling "out" port of procQ with "in" port of EF
     addCoupling(p,"out",e,"in"); 
	 //Coupling "out" port of EF with "in" port of procQ
     addCoupling(e,"out",p,"in");

     showState();
}
    /**
     * Automatically generated by the SimView program.
     * Do not edit this manually, as such changes will get overwritten.
     */
    public void layoutForSimView()
    {
        preferredSize = new Dimension(604, 292);
        ((ViewableComponent)withName("p")).setPreferredLocation(new Point(32, 103));
        ((ViewableComponent)withName("EF")).setPreferredLocation(new Point(245, 71));
    }
}

generator도 수정되어야 하는데, 방법은 지난번과 유사하며 변수 값만 바뀌었다.

/* genr4.java */
/* modified by Aettie Ji*/
/* March, 23. 2009 */

package SimpArc;

import simView.*;

import java.lang.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class genr4 extends ViewableAtomic{

  protected double int_arr_time;
  protected int count;

  public genr4() {this("genr4", 30);}

public genr4(String name,double Int_arr_time){
   super(name);
   addInport("in");
   addOutport("out");
   addInport("stop");
   addInport("start");
   int_arr_time = Int_arr_time ;
}

public void initialize(){
   holdIn("active", int_arr_time);

     count = 0;
     super.initialize();
 }

public void  deltext(double e,message x)
{
Continue(e);
if(phaseIs("passive")){
   for (int i=0; i< x.getLength();i++)
      if (messageOnPort(x,"start",i))
         holdIn("active",int_arr_time);
	}
 if(phaseIs("active")){
   for (int i=0; i< x.getLength();i++)
      if (messageOnPort(x,"stop",i))
         phase = "finishing";
	}
}

public void  deltint( )
{

if(phaseIs("active")){
   count = count +1;
   holdIn("active",int_arr_time);
}
else passivate();
}

public message  out( )
{
  //Generation time of the generator is repeatedly changed 
  //(15↔30, initial generation time = 15)
  if (int_arr_time==15)
  {
    int_arr_time = 30;
  }
  else
    int_arr_time = 15;

   message  m = new message();
   content con = makeContent("out",
            new entity("job" + count));
   m.add(con);

  return m;
}

public void showState(){
    super.showState();
    System.out.println("int_arr_t: " + int_arr_time);
}

public String getTooltipText(){
   return
   super.getTooltipText()
    +"\n"+" int_arr_time: " + int_arr_time
     +"\n"+" count: " + count;
  }
}

마지막으로 EF model

/* ef1.java */
/* modified by Aettie Ji*/
/* March, 23. 2009 */

package SimpArc;

import simView.*;

import java.awt.*;
import java.io.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class ef1 extends ViewableDigraph{

public ef1(){
    super("ef1");
    efConstruct(10,500);
}

public ef1(String nm,double int_arr_t,double observe_t){
    super(nm);
    efConstruct(int_arr_t,observe_t);
}

public void efConstruct(double int_arr_t,double observe_t){

    addInport("in");
    addOutport("out");
    addOutport("result");

	//Using genr4("name", int_arr_t) for changing generation time repeatedly
    ViewableAtomic g = new genr4("generator",int_arr_t); // generator와
    ViewableAtomic t = new transd("transducer",observe_t); // transducer를 생성

     add(g); //추가
     add(t);

     initialize();
     // 각 port의 coupling
     addCoupling(g,"out",t,"ariv");
     addCoupling(this,"in",t,"solved");
     addCoupling(t,"out",g,"stop");
     addCoupling(this,"start",g,"start");
     addCoupling(this,"stop",g,"stop");
     addCoupling(g,"out",this,"out");
     addCoupling(t,"out",this,"result");

    preferredSize = new Dimension(279, 146);
    g.setPreferredLocation(new Point(6, 17));
    t.setPreferredLocation(new Point(-5, 81));
}
    /**
     * Automatically generated by the SimView program.
     * Do not edit this manually, as such changes will get overwritten.
     */
    public void layoutForSimView()
    {
        preferredSize = new Dimension(289, 221);
        ((ViewableComponent)withName("transducer")).setPreferredLocation(new Point(-7, 140));
        ((ViewableComponent)withName("generator")).setPreferredLocation(new Point(4, 44));
    }
}

transducer의 trajectory이다.
성능 관련 계산 값들이 포함되어 있으므로 확인하면 될듯...

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

DEVS의 Introduction
그냥 쭉 훑어보기만 했다는..ㅋㅋㅋ
두 번째 시간에는 GPT diagraph model에 대해 살펴보았다.
말 그대로 generator, processor, transducer 세 개의 atomic model이 모여 이루어진 기본적인 모델이다.

각 atomic model간의 port 연결 관계 및 하는 일들을 살펴보자.

GENERATOR

External function : 
	- if messageOnPort(“start”) then holdIn("active", int_arr_time);
	- if messageOnPort(“stop”) then phase = “finishing”;
Internal function : 
	- count++;
	- holdIn("active", int_arr_time);
Output function : 
	- “out” : “job”+count를 proc에 보냄

외부 함수는 어떤 port로 메시지가 전달되는가에 따라 generator가 무슨 일을 하는지를 나타낸다.
즉, start port로 메시지가 오면, holdIn()을 호출하는데, 이 메소드는 int_arr_time의 시간에 "active"라는 상태가 된다는 의미이다.
stop port에 메시지가 들어오면 job을 생성하는 일을 중단한다.
내부 함수는 generator내부에서 일어나는 일이다.
발생시키는 job의 갯수를 세고, 특정 시간(int_arr_time) 간격으로 "active"상태가 되도록 한다.
즉, 특정 시간 간격으로 job이 생성된다.
output 함수는 내부적으로 발생한 job을 외부로 전달하는 역할을 하는데, generator에서는 job+count 메시지를 processor에 전달하게 된다.

PROCESSOR

External function : 
	- if messageOnPort(“in”) then holdIn("busy", processing_time);
Internal function : 
	- passivate();
Output function : 
	- “out” : entity job

마찬가지로, processor의 in port로 메시지가 들어오면, processing_time동안 busy상태가 된다.
즉, job을 처리하는 시간이다.
passivate()메소드는 현재 상태를 passive로 만든다.
processor의 초기 상태는 passive로, 상태가 passive여야지만 외부로부터 in port로 메시지를 받아 처리할 수 있다.
processing_time만큼 처리가 완료된 job은 out port를 통해 메시지로 내보내진다.

TRANSDUCER

External function : 
	- clock = clock + e;
	- if messageOnPort(“ariv”) then put(val.getName(), new doubleEnt(clock));
	- if messageOnPort(“solved”) 
             then arrival_time = num.getv();
                   turn_around_time = clock - arrival_time;
                    total_ta = total_ta + turn_around_time;
                   solved.put(val, new doubleEnt(clock)); 
Internal function : 
	- passivate();
Output function : 
	- “out” : avg_ta_time 를 genr에 보냄

transducer는 turn around time과 throughput을 계산하는 일을 한다.
때문에 generator에서 job이 발생되고, processor에서 job이 처리완료 되었을 때 나오는 메시지를
ariv와 solved port를 통해 받고 그 시간을 계산한다.
turn_around_time의 평균은 generator에게 다시 전달된다.


아웅...이런 간단한 것도 설명하기 참 어렵군하...ㅜ_ㅜ
노파심에 다시 한 번 적는 건...
이 포스팅은 복습의 의미이기 때문에 틀린 정보가 들어있을지도 모른다는 것...
뭐 별로 참고할 것도 없지만, 혹시 참고하다가 틀린 점이 있으면 지적해주시는 센수~^^*


자, 그럼 두번째 시간에 해야 할 일은 무엇인고 하니...

1. Make the gpt2.java, which is modified from the gpt.java file. In the GPT diagraph model, the GPT2 digraph model includes the generator, the processor with queue (procQ.java) and the transducer. Note that the Processor has 15 processing time and the Transducer has 150 observation time, and the generation time of the Generator is repeatedly changed (10↔20, initial generation time = 10). Expect and draw the trajectory of the Transducer. Compare with simulation results of the GPT digraph model.
2. What is each average of TA (Turn Around time) of the GPT digraph model and the GPT2 digraph model? TA is the time required to solve a job (the processing time + the waiting time in queue)
3. What is each throughput of the GPT digraph model and the GPT2 digraph model? Throughput is the number of solved jobs by the DEVS time.

아...참 많은 일을 해야 하는구나...
일단, 원래 gpt.java를 수정하는데, 일반 processor가 아닌 queue processor를 사용하고,
generator는 10, 20으로 job발생 간격을 계속 바꾸라는 것이고,
processor는 15 processing time을 갖으며,
transducer는 150 초 동안 이것 저것 계산하다가, 그 시간이 되면 generator에게 결과와 함께
이제 그만 job 생성을 멈추시오~라는 메시지를 날리는거다.
일반 processor와 queue procesor의 성능을 turn around time과 throughput을 이용해 비교해보라고 하는데,
이건 생략하고(제출안했기 땜에 정리하지 않았다능..ㅋㅋㅋ, 표시되는 출력결과에 나오기 때매 직업 확인해보면 될듯...)

GPT model

// gpt2.java
// modified by Aettie Ji
// March, 17. 2009

package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class gpt2 extends ViewableDigraph{

public gpt2(){
    super("gpt2");

    ViewableAtomic g = new genr3("g",10); // job 발생시간 변경을 위해 수정한 generator 사용
    ViewableAtomic p = new procQ("p",15); // queue processor 사용
    ViewableAtomic t = new transd("t",150); // transducer

     add(g);
     add(p);
     add(t);
// diagraph model에 port 추가
    addInport("in");
    addInport("start");
    addInport("stop");
    addOutport("out");
    addOutport("result");
// 각 port의 연결
     addCoupling(this,"in",g,"in");
     addCoupling(this,"start",g,"start");
     addCoupling(this,"stop",g,"stop");
     addCoupling(g,"out",p,"in");
     addCoupling(g,"out",t,"ariv");
     addCoupling(p,"out",t,"solved");
     addCoupling(t,"out",g,"stop");
     addCoupling(p,"out",this,"out");
     addCoupling(t,"out",this,"result");

     showState();
}
    /**
     * Automatically generated by the SimView program.
     * Do not edit this manually, as such changes will get overwritten.
     */
    public void layoutForSimView()
    {
        preferredSize = new Dimension(816, 409);
        ((ViewableComponent)withName("p")).setPreferredLocation(new Point(322, 274));
        ((ViewableComponent)withName("g")).setPreferredLocation(new Point(235, 118));
        ((ViewableComponent)withName("t")).setPreferredLocation(new Point(485, 61));
    }
}

수정한 generator

package SimpArc;

import simView.*;

import java.lang.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class genr3 extends ViewableAtomic{

  protected double int_arr_time;
  protected int count;

  public genr3() {this("genr3", 30);}

public genr3(String name,double Int_arr_time){
   super(name);
   // generator의 port들
   addInport("in"); 
   addOutport("out");
   addInport("stop");
   addInport("start");
   int_arr_time = Int_arr_time ; // 초기 int_arr_time을 매개변수로 받음.
}

public void initialize(){
     holdIn("active", int_arr_time);
     count = 0;
     super.initialize();
 }

public void  deltext(double e,message x)
{
	Continue(e);
	if(phaseIs("passive")){ // passive일 때, start port로 입력이 있으면
	  for (int i=0; i< x.getLength();i++)
	    if (messageOnPort(x,"start",i))
	      holdIn("active",int_arr_time); // active
	}
	if(phaseIs("active")){ // active 때, stop port로 입력이 있으면
	  for (int i=0; i< x.getLength();i++)
	   if (messageOnPort(x,"stop",i))
	        phase = "finishing"; // 종료
	}
}

public void  deltint( )
{
	if(phaseIs("active")){ // active 이면
	   count = count +1; // job count 증가
	   holdIn("active",int_arr_time); 
	}
	else passivate();
}

public message  out( )
{
  if (int_arr_time==10) // int_arr_time을 10<->20으로 교환
  {
    int_arr_time = 20; 
  }
  else
    int_arr_time = 10;

  message  m = new message();
  content con = makeContent("out", new entity("job" + count));
  m.add(con);
  return m; // 메시지를 생성하여 리턴
}

public void showState(){
    super.showState();
    System.out.println("int_arr_t: " + int_arr_time);
}

public String getTooltipText(){
   return
   super.getTooltipText()
    +"\n"+" int_arr_time: " + int_arr_time
     +"\n"+" count: " + count;
  }

}

위와 같이 수정했을 때의 trajectory
그림 그리기가 더 빡시더라...ㅜ_ㅜ

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

이번 학기에 듣는 수업이다.
대학원에서는 흔치 않은 1시간 수업에 2시간 실습이 잡혀있는 수업으로...
소프트웨어의 수학적 모델링에 대해 배우고, DEVS를 이용해서 실습한다.

코딩이 딸리는 나로서는 조금 부담스러운 과목이 아닐 수 없지만
나중에 유용하게 쓰일 수도 있을 것 같고 나름 재미도 있다.

자세한 내용은 위키를 참고 하시기 바라며 http://en.wikipedia.org/wiki/DEVS...^^

내 포스팅의 목적은 늘 그렇듯이,
나중에 잊을때를 대비한 자료 축적 이거나, 사진이 아까워서이다.
그래서 뭔가 정보를 얻기 위해 여기를 찾아오신 분들께는 어쩌면 도움이 별로 안될지도 모른다.
순수하게 내 위주로 되어있기 때문이랄까...ㅋㅋㅋ

뭐 각설하고, 그리하여 매 시간 충실히 수행하고 있는 실습 과제를 조금 정리해보고자 한다.
실습에 사용되는 DEVSJAVA의 코드는 http://www.acims.arizona.edu/SOFTWARE/software.shtml 여기서 다운 받을 수 있고,
뭔가 라이센스 폼을 보내는 복잡한 과정이 있는 듯 하여 파일을 직접 올리지 않으려고 한다.
(나는 교수님께서 제공하신 강의용을 사용하고 있는지라..ㅋㅋ)

음...수업에서 JBuiler 5를 사용하기 때문에 그걸 썼다.
(이클립스 써보려다 삽질하고 포기..ㅜ-ㅜ)


우리는 이제 소프트웨어를 모델링 하는 걸 배울거다...차근차근..ㅋㅋㅋ
일단 모델은 여러 Atomic model과 이 Atomic model 들이 여러 개 모여 만들어지는 Diagraph model로 이루어진다.
GENERATOR는 당연히 JOB을 생성하고, PROCESSOR는 JOB을 실행해서 결과를 낸다.
다음은 PROCESSOR의 pseudo-code이다.

Primary States:
Phase: busy
Sigma: any positive number

Parameters:
Job-id: alpha-numeric (e.g. job-1)
Processing-time: any positive number (e.g. 50)

Input port: in
Output port: out

External Transition Function:
     when receive input on input port “in” 
          if phase is passive
          job = input
          hold_in “busy” for processing-time
     else if phase is busy    // busy processing job

          continue                // ignore input
     else 
          error

Internal Transition Function:
If phase is busy
     set phase to passive 
     set sigma to Infinity

Output Function:
     Send “job”+id to output port “out”    // send input (i.e. job-id) to output port “out”   

이제 우리가 할 일은 이렇다.
1. Make the gproc.java, which is modified from the gpt.java file. The gproc digraph model includes the generator and the normal processor. You must remove all references to the transducer “t”, which is not needed in this digraph model. Expect and draw the trajectory of the normal processor. Compare with simulation results of the gproc digraph model.
2. Note that the generation time of a generator is changed from 20 to 30 if the number of jobs exceeds 5 and the normal processor has 50 processing time.

요걸 하기 전에, 우리가 건드려봐야 할 파일들은 좀 보면,

SimpArc아래에...

파일 이름들을 보면 대충 건드려야 할 파일들을 알 수 있다.

일단 문제에서 말한 대로 gpt.java파일을 참고하여, gproc.java파일을 생성한다.

// gproc.java
// modified by Aettie Ji 
// March, 17. 2009 

package SimpArc;

import java.awt.*;
import simView.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class gproc extends ViewableDigraph{
public gproc(){
    super("gproc");

    ViewableAtomic g = new genr2("g",20); //GENERATOR with initial generation time 20
    ViewableAtomic p = new proc("p",50); //PROCESSOR with processing time 50

     add(g); //GENERATOR add
     add(p); //PROCESSOR add

     addInport("in"); //port add
     addInport("start");
     addInport("stop");
     addOutport("out");

     addCoupling(this,"in",g,"in"); //coupling each port
     addCoupling(this,"start",g,"start");
     addCoupling(this,"stop",g,"stop");
     addCoupling(g,"out",p,"in");
     addCoupling(p,"out",this,"out");

     showState();
    /*
    preferredSize = new Dimension(484, 145);
    g.setPreferredLocation(new Point(13, 18));
    p.setPreferredLocation(new Point(195, 18));
    t.setPreferredLocation(new Point(193, 80));
    */
}
    /**
     * Automatically generated by the SimView program.
     * Do not edit this manually, as such changes will get overwritten.
     */
    public void layoutForSimView()
    {
        preferredSize = new Dimension(816, 409);
        ((ViewableComponent)withName("p")).setPreferredLocation(new Point(322, 274));
        ((ViewableComponent)withName("g")).setPreferredLocation(new Point(235, 118));
        ((ViewableComponent)withName("t")).setPreferredLocation(new Point(485, 61));
    }
}

특별히 수정한 것은 없고, gpt.java파일은 세 개의 atomic model인 generator, processor, transducer를 모은 diagraph model이므로
transducer에 관련된 내용을 모두 제거했다. 각 모델이 가져야 하는 port에 대해서는 아직 잘 모르겠다...
그건 좀 더 배우면...ㅋㅋㅋ
일단은 defalut로 되어 있는 것임...
또 한가지 수정 사항은, 예제의 genr.java 가 아닌 새로운 Generator를 만든 것인데...
이것은 문제에서 나온대로 초기 job 생성 시간을 5개 생성이후에 변경해 주기 위해서이다.

// genr2.java
// modified by Aettie Ji 
// March, 17. 2009 

package SimpArc;

import simView.*;

import java.lang.*;
import genDevs.modeling.*;
import genDevs.simulation.*;
import GenCol.*;

public class genr2 extends ViewableAtomic{

  protected double int_arr_time;
  protected int count;

  public genr2() {this("genr2", 30);}

public genr2(String name,double Int_arr_time){
   super(name);
   addInport("in");
   addOutport("out");
   addInport("stop");
   addInport("start");
   int_arr_time = Int_arr_time ; //set int_arr_time
}

public void initialize(){
   holdIn("active", int_arr_time);
    //  phase = "passive";
   //  sigma = INFINITY;
     count = 1;
     super.initialize();
 }

public void  deltext(double e,message x)
{
Continue(e);
if(phaseIs("passive")){
   for (int i=0; i< x.getLength();i++)
      if (messageOnPort(x,"start",i))
         holdIn("active",int_arr_time);
}
 if(phaseIs("active"))
   for (int i=0; i< x.getLength();i++)
      if (messageOnPort(x,"stop",i))
         phase = "finishing";
}

public void  deltint( )
{
/*
System.out.println(name+" deltint count "+count);
System.out.println(name+" deltint int_arr_time "+int_arr_time);
System.out.println(name+" deltint tL "+tL);
System.out.println(name+" deltint tN "+tN);
*/

if(phaseIs("active")){
   count = count +1; //발생된 job의 갯수 세기
   holdIn("active",int_arr_time);
}
else passivate();
}

public message  out( )
{
   if (count >= 5) // Job이 5개 이상 발생되면, 
       {
         int_arr_time = 30; //int_arr_time을 30으로
       }
   message  m = new message();
   content con = makeContent("out",
            new entity("job" + count));
   m.add(con);
  return m;
}

public void showState(){
    super.showState();
    System.out.println("int_arr_t: " + int_arr_time);
}

public String getTooltipText(){
   return
   super.getTooltipText()
    +"\n"+" int_arr_time: " + int_arr_time
     +"\n"+" count: " + count;
  }
}

int_arr_time이 job의 발생 간격이며, 이는 out() method에서 제어한다.
상당히 복잡하다..ㅜ_ㅜ
요 녀석의 Trajectory는...
이렇게 그려진다.

실행화면도 하나 넣어볼까?
160 time에 job7이 generator에서 발생하여 processor로 넘겨지는 화면이다.
step을 누르면 각 이벤트 발생 시점마다의 화면을 볼 수 있다.

각 method에 대한 설명은...역시 천천히 정리하도록 하겠다...
(뭔가 많이 들은 것도 같고, 이미 3주나 수업이 진행되었는데도...잘 모르겠는...ㅜ_ㅜ)

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

언젠가 블로깅 하면서 본 이 깔끔한 코드 정리 폼을 얼마나 찾아다녔는지...
상단의 물음표 버튼만 누르면 될 것을...

난 바보인가보다...

소프트웨어 공학 수업 내용을 차례로 정리해 놓으려고 마음먹고 일단 이 폼부터 찾으러 다고 찾았다.

오늘 늦게 오긴 했지만, 벌써 4시도 넘었고...ㅜ_ㅜ,
한 달 정도 기운만 있고 정작 걸리지 않는 감기 몸살과
충치는 왼쪽인데 정작 오른쪽이 쿡쿡 쑤여대는 치통과 투쟁중이다...ㅜㅜ

그래도 오늘 마음먹은 건 다 해버려야 할텐데...
(1+1 행사를 하는 Alice Qee따윈 얼릉 잊어버리고 말야..1300k에서, 그것도 오늘까지..ㅋㅋㅋ)

일단 테스트 겸, 나중에 잊어버릴 때를 대비한 백업 겸 해서 설치 내용과 삽입 코드 정리..ㅋㅋㅋ

다운 받는 곳은 여기 http://alexgorbatchev.com/wiki/SyntaxHighlighter:Download
자세한 사용법은 여기 http://alexgorbatchev.com/wiki/SyntaxHighlighter:Usage

압축을 풀고, Tistory ADMIN\스킨\HTML/CSS편집\파일업로드 를 클릭하여 필요한 파일을 업로드 하자.
scripts/*
styles/*
이 폴더의 모든 파일을 업로드 하면 되는데...(다는 필요없고, 사실 사용할 언어에 대한 파일만 업로드하면 되지만...귀찮으니 다 한다.)
Tistory ADMIN에서는 모두 images/폴더 및으로 업로드 되기 때문에 요걸 기억해두고...

이제 skin.html 파일에 몇 줄을 추가한다. head 태그 안에다가 요렇게...

여기서도 마찬가지로 본인이 사용할 언어의 파일만 넣어주면 된다는 거...

사용은 요렇게...

<PRE class="brush: java">
//이 안에다 뭔가 원하는 코드를 써주삼!!
</PRE>

사용 언어의 브러쉬 리스트는 요기 http://alexgorbatchev.com/wiki/SyntaxHighlighter:Brushes
글을 작성할 때는 EDIT모드가 아닌 HTML모드로...
자꾸만 삽입되는 </br> 태그 주의!!

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

2005년도에, 처음 석사 들어왔을때 연구실 선배들과 했던 AI 세미나 때 만들었던 자료다.
발표해 본 경험도 없는데다, 내용도 너무 어려워서
(같은 책으로 학부때 수업을 들었음에도 불구하고, 그게 조박사 수업이었던지라...)
엄청 떨었던 기억이...피피티도 왜 이리 허접한지..ㅋㅋㅋ

교재는 요거... "Artificial Intelligence: A Modern Approach" Stuart Russell and Peter Norvig

지난 논문들과 자료들을 정리하다보니, 연구실 KM 밑바닥에 요런게 있어서 올려본다...
너무 허접해서 누가 참고할 수 있을만한 내용도 아니지만 서도..ㅋㅋㅋ

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

요즘은 매우 바쁘다...

할 일도 많고 나이도 많기 때문에 시간은 없는데 말이다.

이러고 있다.

"바보야, 그렇게 살지마. 니가 그렇게 사니까 나라가 망하는 거야."

이건 예전부터 하고 싶었던 취미생활의 일환으로, 전문적인 지식 없이 그냥 한 번 재미있을 것 같다는 생각에 밑도 끝도 없이 덤벼보는 그런 거, 말이다.

설치형 블로그를 내 컴에서 돌리는 걸 한 번 시도해보자.

이것 저것 만지면서 웹 프로그래밍 공부를 좀 해볼까 하는 생각도 들고 말야.

컴퓨터 공학 박사 과정이다. >_</

하지만 컴퓨터 포비아이다.

성공만 한다면 곧 거미줄 칠 것 같은 네이버 블로그에서 슈웅~하고 이사가는 거다.

그럼 웹서버부터 설치해야...하고 보니까 얼마 전에 xp를 밀고, vista를 깔아버렸다.

자, 검색, 검색...해보니...MySQL과 Apache를 vista에 설치하는데 이래저래 문제가 생긴다고들 하신다. _ㅡ_

에잇, 몰랏!

그냥 APM_Setup을 깔아보는거다...하다가 안되면 말고..(사실 어떤 분이 시도해 보았더니 괘안타더라고 말씀하신 포스트를 보고...)

http://www.apmsetup.com/ 요기에 들어가서 APM_Setup 5를 다운받아 설치, 대부분 C 드라이브에 설치되는 기본 설정대로 설치하라고들 하신다.

설치를 마치고 체크되어 있는대로 종료하면, 이렇게 Apache와 MySQL 서버가 실행된다. vista의 권한 문제 때문인지 맨 처음 자동 실행이 한 번 종료되지만 다시 실행하면 별 문제가 일어나는 것 같지는 않다. 

예전에도 패스워드 막 바꿨다가 접속이 안되고 어찌저찌 열받고, 지우고 다시 깔고...하는 짓들을 반복한 경험이 있기 때문에 이번 기회에 차근하게 정리를...

http://www.apmsetup.com/ 사이트의 tutorial 부분을 참고 했다.

함께 열리는 README 파일을 보면 패스워드에 관련된 내용이 기술되어 있다. 초기 설치시의 APM_Setup 관리페이지의 패스워드와 MySQL root 패스워드는 apmsetup, 또한 phpMyAdmin 에 로긴 하실 때에도 ID / PS 를 root / apmsetup 라고...

관리자 패스워드는 바로 저 아래 환경설정 버튼을 눌러서 나오는 창의 APM_Setup 환경설정 메뉴탭에서 변경한다.

http://localhost/로 접속하면 아래와 같는 화면이 뜬다.

위 쪽 메뉴에서 맨 오른쪽 phpMyAdmin을 클릭하면, README 파일에 나온대로 root/apmsetup을 아이디와 패스워드로 치고 접속한다.

여기서 암호 변경을 클릭하고 패스워드를 변경한 후("1234"로 변경), 수정 버튼을 클릭하면 접속이 종료된다. 그러나, 이전의 패스워드든 바뀐 패스워드든 어떤 것으로도 접속할 수가 없다. (다른 분들도 그러신 건지는 잘 모르겠지만...)

이제 C:\APM_Setup\Server\phpMyAdmin 폴더를 찾아가자. config.inc.php 파일을 Editplus 같은 걸로 열어서, 다음 부분을 변경해준다.

$cfg['Servers'][$i]['controluser']   = 'root';          // MySQL control user settings
                                                                        // (this user must have read-only
$cfg['Servers'][$i]['controlpass']   = '1234';         // access to the "mysql/user"
                                                                        // and "mysql/db" tables).
                                                                        // The controluser is also
                                                                        // used for all relational
                                                                        // features (pmadb)

저 패스워드 부분이 변경되지 않은 채 'apmsetup'으로 되어 있었는데, 앞서 변경한 대로'1234'로 변경하여 저장한다. 그 다음, APM_Setup Monitor의 환경설정에서 MySQL 환경설정 탭에서 MySQL root 패스워드를 똑같이 '1234'로 변경한다. 이제, 서버를 모두 껐다가 재시작해도 이 패스워드로 phpMyAdmin에 접속이 된다는...ㅋㅋㅋ

그러면, 이제 데이터 베이스를 만들자. 블로그를 설치했을 때 여러 테이블들이 들어갈 데이터 베이스를 생성하는데, 설치시에 default로 생성된 mysql 데이터베이스를 그냥 사용해도 될 듯하다. 그래도 한 번 생성해 볼까...? myphpMyAdmin으로 아이디와 패스워드를 치고 딱 들어가서,  새 데이터 베이스 만들기에 원하는 데이터베이스 이름을 딱 쳐준다.

내 경우는 'blog_db' !!

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

 IAR 프로젝트 사전 조사 명목의 온톨로지 툴에 대한 조사 발표

Creative Commons License

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.