Creative Commons License

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

물론 내 타겟은 아니고..ㅋㅋㅋ
난 살짝 참여할지도...(그닥 많이 참여가 안될지도..ㅋㅋㅋ)
그래도 마음을 가다듬는 의미에서 포스팅...ㅋㅋㅋ



http://socialgamingplatform.com/msm09/index.html

Call for Papers for a Special Issue of International Journal of Electronic Commerce on MINING SOCIAL MEDIA

GUEST EDITORS
Jose C. Cortizo, CTO, principal researcher on Social Media at Social Gaming Platform, professor at
Universidad Europea de Madrid. josecarlos.cortizo@wipley.com
Francisco M. Carrero, CEO, principal researcher on Recommender Systems at Social Gaming Platform,
professor at Universidad Europea de Madrid. francisco.carrero@wipley.com
Jose M. Gomez, Research Director at Optenet, jgomez@optenet.com

OVERVIEW
Recently, Forrester published a report, “The Future of the Social Web” where they sketched a timeline of the development of the Social Web, dividing its evolution in 5 eras. According to that report, the first era of the development of the Social Web started to explode the social relationships among users. Then, in the social functionality era, these social relationships resulted in the social functionality era where several websites started to add social functionalities in order to help users to interact with their peers. We are now in the era of Social Colonization, where technologies like Facebook Connect or Google Friend Connect have standardized social functionalities among websites and a vast majority of websites now include several social functionalities. Soon these federated identities will empower people to enter the era of social context with personalized and social content, and the development of tools for personalize social content will aim the development of the era of social commerce The primary goal of the proposed special issue of International Journal of Electronic Commerce is to foster research in the interplay between Social Media, Data Mining and Electronic Commerce, trying to reflect the actual developments on technologies that fit on the Social Context era.

SCOPE
The International Journal of Electronic Commerce is the #1-ranked journal on Electronic Commerce globally. This Special Issue will provide a significant opportunity for authors to publish important novel and original contributions in the area of Data Mining applied to Social Media. The guest editors seek papers and proposals that address various aspects of Mining Social Media, including recommender systems for social media, data mining algorithms designed to explode Social Networks, information management for Social Networks, etc.

RESEARCH QUESTIONS
We invite scholars and professionals from a broad range of disciplines to submit to this Special Issue. Papers
may encompass any or all of the following: foundational theoretical analyses, modelling, simulation, and
empirical studies. Authors may examine different aspects of mining social media in any of a variety of possible
contexts. Special topics of interest include, but are not limited to, the following:

A. Data Mining for Social Networks
• Novel Algorithms
• Association Rules
• Mining semi-structured data
• Classification and Ranking
• Clustering
• Text Mining
• Machine Learning
• Privacy Preserved Data Mining
• Statistical Methods
• Temporal and spatial data mining
• Parallel and Distributed Data Mining
• Interactive and Online Mining
• Data and Knowledge Visualization
• Multimedia mining (audio/video)
• Ensemble Methods
• Web Mining
• Graph Mining
• Link Mining

B. Information Management for Social Networks
• Recommender Systems
• Information Retrieval
• Sentiment Analysis
• Natural Language Processing
• Question Answering
• Semantic Processing
• Graph Analysis and Complex Networks
• Social Network Analysis

C. Possible applications
• Electronic Commerce
• E-Mail Spam Detection
• Blog/Social Networks Spam Detection
• Community Detection
• Users/content recommenders
• Trends discovery
• Blogs/Social Networks Community Dynamics
• User Reviews Ranking
• Blogs/Social Networks Contributions Summarization
• Abuse/Fraud Detection
• User Profile Modelling
• Event Detection and Tracking in Social Media
• Online Advertising

SUBMISSION GUIDELINES
Manuscripts submitted to the special issue should contain original material not published in nor submitted to other journals. Each manuscript has to have a cover page with the author information and another page with title and abstract but the author information omitted. The review process is double-blind and papers which do not meet publication quality standards will be rejected before the review process. Interested authors are required to submit extended abstracts of no more than two pages for their planned
submissions. This will give the editorial team an opportunity to determine if a given submission is appropriate or expedited handling and review.
Full papers should be sent via e-mail to Jose Carlos Cortizo <josecarlos.cortizo@wipley.com> in anonymized PDF Format, not including any author names or affiliations, and should not exceed 40 pages.

IMPORTANT DATES
Abstracts deadline 15 January 2010
Abstracts feedback 30 January 2010
Full paper submission 15 April 2010
Revisions notification 1 June 2010
Revised manuscripts 1 August 2010
Final decision 1 October 2010

GUEST EDITORS
Jose C. Cortizo,
CTO at Social Gaming Platform,
Professor at UEM, Spain
josecarlos.cortizo@wipley.com
Tel: (+34) 912115616
Fax: (+34) 912115611
Francisco M. Carrero,
CEO at Social Gaming Platform,
Professor at UEM, Spain
francisco.carrero@wipley.com
Tel: (+34) 912115616
Fax: (+34) 912115611
Jose M. Gomez
Research Director at Optenet
Spain
jgomez@optenet.com
Tel: (+34) 902154604
Fax: (+34) 913575433

Creative Commons License

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

역시나 오랜만에 다시 연구를 좀 해봐야겠다고 생각해서 읽게 된 논문....
일년 남짓 이 쪽과 담 쌓고 살았으니, 다시 감을 좀 찾기 위해 선배오빠의 논문을 슬쩍 도와주기로 했다.
그래서 요즘 보고 있는건...
사용자가 컨텐츠에 단 태그가 시간이 지남에 따라 그 인기도랄까, 트렌드가 변하게 되는데
그걸 어떻게 하면 잘 측정해서 반영할까..에 대한 관련 연구를 읽고 있다.
읽었으니..기록, 기록, 기록..ㅋㅋㅋ
 

[Review] Trend Detection in Folksonomies

A. Hotho, R. J¨aschke, C. Schmitz, and G. Stumme
Y. Avrithis et al. (Eds.): SAMT 2006, LNCS 4306, pp. 56–70, 2006.
Springer-Verlag Berlin Heidelberg 2006


Abstract
Abstract. As the number of resources on the web exceeds by far the number of documents one can track, it becomes increasingly difficult to remain up to date on ones own areas of interest. The problem becomes more severe with the increasing fraction of multimedia data, from which it is difficult to extract some conceptual description of their contents. One way to overcome this problem are social bookmark tools, which are rapidly emerging on the web. In such systems, users are setting up lightweight
conceptual structures called folksonomies, and overcome thus the knowledge acquisition bottleneck. As more and more people participate in the effort, the use of a common vocabulary becomes more and more stable. We present an approach for discovering topic-specific trends within folksonomies. It is based on a differential adaptation of the PageRank algorithm to the triadic hypergraph structure of a folksonomy. The approach allows for any kind of data, as it does not rely on the internal structure of the documents. In particular, this allows to consider different data types in the same analysis step. We run experiments on a large-scale real-world snapshot of a social bookmarking system.


앞부분은 생략하고,
저자들은 PageRank를 기본으로 folksonomy내의 사용자, 리소스, 태그의 순위를 정한다. 결국 이 관계는 symmetric하기 때문에 사용자, 리소스, 태그의 어느 것에나 같은 방법을 적용할 수 있다.
PageRank를 사용하기 위해서 이들의 관계를 그래프로 나타내는데, tripartite 구조로 표현된다.
첫번째 그림이 일반적인 방향성 그래프의 형태라면, 두번째 그래프는 사용자가 어떤 리소스에 대해 어떤 태그를 사용하여 태깅하였는가를 나타내는 그래프이다.
이 그래프에서, PageRank와 같이 Random sufer model을 사용하는데,
w의 값이 weight, 즉, 해당 elememt의 rank값이 된다.
A는 row-stochastic version of adjacency matrix of the graph라고 되어있는데,
해당 엘리멘터에 대한 edge발생을 반영하기 위한 값으로 대충 이해하고 있다. (정확한 계산을 하려면 나중에 더 찾아봐야겠지만...)
여기서 중요한 건 p와 d의 값인데, p는 preference를 의미하고, d는 이 preference가 식에 얼마나 영향을 미칠것인가를 결정하게 된다.
이 p값을 이용하여, 저자들은 topic-specific한 rank를 결정할 수 있다고 주장하고 있다.
||w||=||p||를 유지하면서, d가 1보다 작을때(논문에서는 0.85)의 값에서 d가 1일때(특정한 preference가 없을때)의 값을 빼서 최종 weight값을 구한다.
실험에서는 메인 토픽 키워에 50%의 p값을 주고, 나머지 관련 태그에 나머지 p값이 그 관련정도에 따라 분포시켜 분석하고 있다. 

다음은 내가 더 관심을 가지고 있는 부분인, 각 엘리먼트의 인기도 변화의 측정 부분이다.

t는 시간 단위, n은 해당 시간의 전체 엘리먼트의 사이즈, r은 해당 시간의 해당 엘리먼트의 랭킹이다.
(이 논문에서는 항상 사용자, 태그, 리소스에 대해서 각각 분석하고, 각 요소에 같은 식을 적용한다.)
수식의 의미는, 상위 90%의 엘리먼트가 80%로 순위가 올라가는 것은, 0.09%에 있는 엘리먼트가 0.08
% 위치로 올라가는 것보다 3배가 쉽다...는 의미로 계산된다. 이렇게 시간 t0 - > t1동안 각 엘리먼트의 순위 변화를 통해 트렌드를 계산한다. 

이 논문에서는 이러한 값을 계산해서 추천에 이용한 것이 아니라, del.icio.us. 데이터를 이용하여 1년동안의 사용자, 태그, 리소스의 추이를 분석했다. 마지막으로 다른 논문의 Interestingness라는 트렌드 측정 방법과 비교하여, 상대적으로 long-term의 트렌드 분석에 본인들의 방법이 유리하다고 말하고 있다. (비교한 방법은 TF/IDF방식을 사용하고 있다....)

Creative Commons License

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

"대한민국의 주권은 국민에게 있고, 모든 권력은 국민으로부터 나온다."

우 리 헌법 1조는 국민주권을 천명하고 있다. 이러한 국민주권을 구체적으로 실현하기 위해 기본권이 보장되어야 함은 불문가지다. 하지만 이명박 정부는 갖은 편법과 권력의 오남용을 통해 기본권을 제한하고 있다. 이는 주권이 국민에게 있다는 공화국의 정신 즉, 민주주의에 대한 중대한 침해행위라고 평가하지 않을 수 없다.

특히 표현의 자유, 집회의 자유는 이명박정부가 들어선 이후 가장 심각하게 침해되고 있는 기본권 영역이다. 표현의 자유가 실존의 개인이라면 누구나 가져야 하는 양심의 자유에 바탕한다면, 집회의 자유는 그런 자유로운 양심에 바탕해서 그 개인이 집단으로서 정치에 참여하고, 사회에 참여할 수 있는 민주주의적 표현형태라고 할 수 있다. 이명박 정부는 이 양자를 모두 옥죄고 있다.

하나, 정부의 언론장악 음모를 비판한다. 언 론관계법을 통한 합법을 가장한 언론장악 시도는 지금 이순간에도 벌어지고 있다. 낙하산 인사를 통한 언론의 친정부화 시도는 MBC와 YTN 노조의 파업사태를 불러일으켰고, KBS의 인사이동 이후 KBS에 대한 비판적인 여론을 불러왔다. 이 일련의 행위는 정치언론을 부활시키고, 국민을 길들이기 위한 수단으로 언론을 전락시키려는 시도로 평가하지 않을 수 없다.

둘, "개인의 명예를 훼손한다." 라는 미명 하에 그 자신 국민이자 시민인 네티즌이 정당하게 행사해야 하는 마땅한 표현의 자유까지 억누르고 있다. 개인의 인격권은 존중되어야 하지만 이를 핑계로 정당한 표현의 자유가 제한되어선 안된다. 이명박 정부 하의 검찰은 듣도 보도 못한 모호한 법률규정을 근거로 정부정책을 비판하는 네티즌을 구속하는 유례 없는 만행을 저지른 바 있다(미네르바 사건). 이는 정당한 정치적 의사표현를 위축시키고, 네티즌이 스스로를 검열하는 자기 검열의 내면화를 유도하고 있다. 반면, 정부 정책에 반하는 공적 인물이나 유명인의 경우엔 공소사실이나 사생활까지 무책임하게 드러내는 등 차별적인 법 집행을 자행하고 있다. 이는 노무현 대통령의 서거라는 국가적인 비극을 불러온 큰 원인으로 작용하기도 했다.

셋, "불법 시위로 변질될 우려가 있다." 라는 실현되지 않은 자의적 추정만으로 평화로운 집회를 원천봉쇄하는 일이 빈번해지고 있다. 심 지어 노무현 대통령 서거 첫날에는 대한문 앞 조문객을 경찰벽으로 막는 반인륜적인 행위도 서슴지 않았다. 그 어느 민주국가가 국민들이 모여 자유롭게 이야기하는 것을 두려워하는가? 그 어느 민주경찰이 촛불을 든 아이를 무등태운 시민에게 촛불을 들고선 출입할 수 없다고 막아서는가?  이명박 정부는 이런 일련의 행위를 통해 스스로 민주 정부임을 포기하고 있다.

넷, 국민들은 정말 끈질긴 인내로 참아왔다. 지난 해 광화문을 가득 채운 촛불의 바다 앞에서 이명박 대통령은 스스로 반성한다고 말했다. 하지만 그 실천은 명박산성으로 표현되었다. 이제 더 이상 말로만 소통을 외치고, 말로만 반성을 외치는 때는 지났다. 구체적인 행동으로 국민과 소통하겠다는 의지를 보여줘야 한다. 하지만 그런 모습은 여전히 발견되지 않는다. 이에 국민들의 인내심은 한계에 다다르고 있다.

우리가 이명박 정부에 원하는 것은 대단한 것이 아니다. 우리는 상식을 원하고, 민주주의를 원하고, 표현의 자유를 원한다. 그리고 자유롭게 모여서 자신의 정치적인 입장을 개진할 수 있는 '열린 광장'을 원한다. 이 것이 왜 실현되지도 않은 자의적 우려에 의해 원천봉쇄되어야 하는가? 이러고도 이명박 정부는 민주주의 공화국의 정부임을 자임하는가? 과연 이명박 정부가 원하는 것은 박정희와 전두환, 노태우로 이어졌던 그 권위주의 정부인가? 우리는 되묻지 않을 수 없다.

시간을 거꾸로 돌리는 이명박 정부의 시계를 이대로 둘 수 없다. 더 이상 침묵하는 것은 4.19 혁명과 5.18 광주민주화항쟁, 그리고 6.10 대항쟁의 역사를 되돌리려는 반역사를 묵인하고, 추인하겠다는 것에 다름 아니다. 무수히 많은 학생과 시민들이 흘린 그 피의 가치를 그저 지워버리겠다는 걸 인정하는 것이고, 피와 땀으로 성취한 대한민국의 자랑스런 민주주의를 포기하겠다는 것이다. 이에 우리 블로거는 시민의 일원으로서 작은 목소리나마 현 시국에 보태지 않을 수 없었다. 우리 블로거들은 현 정부의 오만을 성토하며, 대한민국 민주주의의 발전과 대한민국 국민의 인간답게 살 권리를 위하여 이명박 정부와 여당에 다음과 같이 요구한다.

하나. 일체의 언론장악 시도를 즉각 중단하라. 언론 관계법은 전면적으로 재검토되어야 한다.
하나. 표현의 자유를 보장하라. 특히 온라인 계엄령이라고 할 수 있는 지난 4월 국회 통과된 저작권법은 전향적으로 재개정되어야 한다.
하나. 집회의 자유를 폭넓게 보장하라. 원천봉쇄의 주술을 당장 거두라.
하나. 이명박 대통령은 비판적인 국민의 목소리에 경청하고, 자신의 실정을 반성하고, 사과하라. 그리고 작금의 총체적인 문제에 대한 납득 가능한 합리적인 해법을 제시하라.



* 위 글은 2009.6.11.오전 8:49.에 3차 추고한 글입니다.

* 이 글은 트위터를 중심으로 뜻을 함께한 블로거들이 의견을 모은 시국선언문 기초안을 바탕으로 임의 편집한 글입니다. 아래 링크로 표시된 블로거 시국선언문을 기초로 재편집이 가능하고, 그 초안을 그대로 복사/배포하는 것도 물론 가능합니다. 같은 취지로 제 편집본을 복사/편집/배포하는 것 역시 전적으로 자유입니다. 이 글은 저작권을 일절 주장하지 않습니다. 동료 블로거 여러분의 많은 참여를 당부드립니다.

- 블로거 시국 선언참여자 명단(트위터) : http://dotweets.com/declaration
- 블로거 시국선언문(기초안) : http://docs.google.com/View?id=dtn99t7_3fbhhskd3 
- 도아 (블로거시국선언 현황) : http://offree.net/entry/Blogger-Declaration

Creative Commons License

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

Creative Commons License

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

이걸 이제야 퍼다 나르다니...
나 역시도 자주 우리나라 국민으로서의 직무 유기를 범한다...

Creative Commons License

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

ㅋ컴구 레포트 ㅜ_ㅜ

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

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

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 대한민국 라이선스에 따라 이용하실 수 있습니다.

Creative Commons License

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

정말 무섭다. MB정부...
그래, 뭐...
나는 "수구 세력이 잃어버렸던 10년"동안 20대를 보낸 사람이라서, 자유를 통제하는 것에 익숙치 않고,
그랬기 때문에 오히려 사회 문제에 대한 날카로운 시각을 가질 수 없었던 것이었을런지 모른다.
지금 내 또래의 젊은 사람들이 다 마찬가지일 거다.
그나마 그 안일하고 게으른 시각을 보완해 줄 수 있었던 것이 일부 깨어있는 지식인들이었는데...

우리 나라는 어디로 가고 있는 걸까...
노 대통령님 생전에 한나라당이 정권을 잡을까봐 무섭다는 말씀이
이런 사태를 염려해서였을까...라는 생각이 든다.

20분 정도 시간을 내서 꼭 보시기를...

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 대한민국 라이선스에 따라 이용하실 수 있습니다.

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 대한민국 라이선스에 따라 이용하실 수 있습니다.