Advertisement
Guest User

Untitled

a guest
Jan 20th, 2019
76
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 13.29 KB | None | 0 0
  1. package main
  2.  
  3. import (
  4. "math/rand"
  5. "sync"
  6. "fmt"
  7. )
  8.  
  9. //-------------------------------------------STRUCTS-------------------------------------------
  10. var wg sync.WaitGroup
  11. var wg2 sync.WaitGroup
  12.  
  13.  
  14. var wgSimulationsEnde sync.WaitGroup
  15. var warteAufSteuerlogik sync.WaitGroup
  16.  
  17. type Aufzug struct {
  18. aufzugNr int // aufzug Nr
  19. fahrgaeste int //Anzahl Passagiere
  20. max int //Maximalkapazität
  21. strecke int //Gesamt-Wegstrecke
  22. etage int // aktuelle Etage
  23. zielEtage int // nächster halt
  24. event string // 0 bereit, 1 einsteigend, 2 eingestiegen,3 fahrend, 4 aussteigend, 5 ausgestiegen
  25. }
  26. type Person struct {
  27. wartezeit int//Wartezeit in schritten
  28. soll int//Distanz start- ziel etage
  29. ist int// tatstächlich gefahrene Strecke
  30. abweichung int // differenz zwischen ist und soll
  31. start int // Startegage
  32. ziel int //Zieletage
  33. status int // 0 = wartend auf zuteilung, 1 = zugeteilt, 12 einsteigend, 2 = fahrend, 23 aussteigend, 3 = ausgestiegen
  34. aufzugNr int // nr des befördernden aufzugs
  35. }
  36. type Zentrale struct {
  37. anzSim int // anzahl an Simulationsläufen
  38. anzAufz int // anzahl Aufzüge
  39. maxPers int // maximale anzahl an personen pro simulation
  40. dauer int // dauer des simulationslaufs in Gesamtschritten
  41. algNr int // aufzugalgorithmen (Nr)
  42. auswertung []Auswertung // auswertung weiteres struct ???
  43. }
  44. type Auswertung struct { // alle aufzüge addiert!!!
  45. wartezeitP int //gesamtwartezeit der passagiere in schritten
  46. abweichungP int // gesamtdifferenz von soll- zu ist-strecken der passagiere in schritten
  47. streckeA int // gesamtstrecke aller Aufzüge addiert
  48. }
  49.  
  50. type aufzugUndPerson struct{
  51. p [] Person
  52. a [] Aufzug
  53. }
  54.  
  55. var channelAuswertungAufzuege= make (chan []Aufzug,1)
  56. var channelAuswertungPersonen=make(chan []Person,1)
  57.  
  58.  
  59. // ---------------------------------------------ZENTRALE STEUERLOGIK----------------------------------------
  60. func ZentraleSteuerlogik() {
  61.  
  62. auswertungsListe := make([]Auswertung,0)
  63.  
  64. anzahlSimulationsläufe := 1
  65. anzahlAufzüge := 4
  66. dauer := 1000
  67. maxPersonen := 10
  68.  
  69. // angegebene anzahl von Simulationsläufen aufrufen, auswertung wird als rückgabewert erhalten und an liste angehängt
  70. for i := 0; anzahlSimulationsläufe > i; i++{
  71.  
  72. auswertung := Steuersimulation(anzahlAufzüge,dauer,maxPersonen)
  73. auswertungsListe = append(auswertungsListe,auswertung)
  74.  
  75. println("Abweichung Personen",auswertung.abweichungP,"Strecke Aufzug=",auswertung.streckeA,"Wartezeit P=",auswertung.wartezeitP)
  76. }
  77.  
  78. wgSimulationsEnde.Done() //Hier angekommen, sind die Simulationenfertig
  79.  
  80. }
  81.  
  82.  
  83.  
  84.  
  85. //----------------------------------------------STEUERLOGIK EINES SIMULATIONSLAUFS---------------------------------------------------
  86.  
  87. func Steuersimulation (anz, dauer, maxPers int/*, algorithmus func()*/)(auswertung Auswertung){
  88.  
  89. // slices erzeugen
  90. aufzugListe := make([]Aufzug,0)
  91. fahrgaesteListe := make([]Person,0)
  92.  
  93. // channels erzeugen
  94. channelGP := make (chan Person,maxPers)
  95. channelGA := make (chan Aufzug,anz)
  96. //channelAlgP := make (chan []Person, maxPers*4)
  97. //channelAlgA := make (chan []Aufzug,anz*4)
  98.  
  99.  
  100.  
  101. aufzugUndPersonCHAN:=make(chan aufzugUndPerson)
  102.  
  103.  
  104.  
  105. //generiere Aufzüge
  106. GeneriereAufzuege(anz, channelGA) // aufzüge erzeugen
  107. //empfange Nachrichten von generiere Aufzug, solange welche gesendet werden
  108.  
  109. for i:=0;i<anz;i++{
  110. neuerAufzug := <-channelGA
  111. aufzugListe = append(aufzugListe, neuerAufzug)
  112.  
  113. }
  114.  
  115.  
  116. // erzeuge neue Personen
  117. GenerierePassagiere(maxPers, channelGP)// übergibt berechnete maximal erlaubte personenanzahl
  118. //empfange Nachrichten von GenerierePassagiere
  119. for i:=0;i<maxPers;i++{
  120. neueAnfragen := <-channelGP // speichere Nachricht in variabel
  121. fahrgaesteListe = append(fahrgaesteListe, neueAnfragen)// hänge neue anfrage an fahrgästeliste an
  122.  
  123. }
  124.  
  125. // algorithmus aufrufen
  126. go Aufzugsteuerungs_Agorithmus_1(aufzugUndPersonCHAN,maxPers, dauer, anz)
  127. // auswertung senden
  128.  
  129. aufzugUndPersonCHAN<-aufzugUndPerson{fahrgaesteListe,aufzugListe}
  130.  
  131.  
  132. a:=<-aufzugUndPersonCHAN
  133.  
  134. println("Test",len(a.p),len(a.a))
  135.  
  136. //nach beendigung der simulation
  137. // erstelle auswertung
  138. for i := range aufzugListe{
  139. auswertung.streckeA += aufzugListe[i].strecke // gesamtstrecke aller Aufzüge addiert
  140. }
  141. for i := range fahrgaesteListe{
  142. auswertung.wartezeitP += fahrgaesteListe[i].wartezeit //gesamtwartezeit der passagiere in schritten
  143. auswertung.abweichungP += fahrgaesteListe[i].abweichung // gesamtdifferenz von soll- zu ist-strecken der passagiere in schritten
  144. }
  145.  
  146.  
  147. //println("Abweichung Personen",auswertung.abweichungP,"Strecke Aufzug=",auswertung.streckeA,"Wartezeit P=",auswertung.wartezeitP)
  148. println("Eine Runde ist fertig")
  149. return // gibt auswertung des simulationslaufs zurück
  150.  
  151. }
  152.  
  153. //--------------------------------------------GENERIERE AUFZÜGE---------------------------------------------------
  154. func GeneriereAufzuege (anzA int, channelGA chan Aufzug){
  155.  
  156. maxPers := 1 // wieviele dürfen höchstens mitfahren
  157. for i := 1; anzA >= i; i++{
  158.  
  159.  
  160. neuerAufzug := Aufzug{i,0,maxPers,0,0,0,"aufzug bereit"}
  161.  
  162. channelGA <- neuerAufzug
  163. }
  164.  
  165. }
  166.  
  167.  
  168.  
  169.  
  170. //------------------------------------------GENERIERE PASSAGIERE-----------------------------------------------------
  171.  
  172. func GenerierePassagiere(max int, channelGP chan Person){ // hier kann anzahl an personen je schritt und anzahl etagen geändert werden
  173.  
  174. for ; max > 0; max--{
  175.  
  176. startEtage := rand.Intn(4)
  177. zielEtage := 0
  178.  
  179.  
  180. for ungleich := false; ungleich == false;{ // damit start und zieletage nicht gleich sind
  181. zielEtage = rand.Intn(4)
  182.  
  183. if startEtage != zielEtage{
  184. ungleich = true
  185. }
  186. }
  187. neueAnfrage := Person{0,0,0,0,startEtage,zielEtage ,0,0} // wie macht man einen channel ????????
  188.  
  189. channelGP <- neueAnfrage
  190.  
  191.  
  192. }
  193.  
  194.  
  195. }
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. //---------------------------------------GOROUTINE PERSON-----------------------------------------------
  203.  
  204. func goroutineP(channelAlgPerson, channelAlgPerson2 chan Person, channelAlgAufzug, channelAlgAufzug2 chan Aufzug,doneChan chan bool){
  205.  
  206. simuLaueft:=true
  207. for simuLaueft{
  208.  
  209. var aufzug Aufzug
  210. var fahrgast Person
  211.  
  212. aufzug = <- channelAlgAufzug
  213. fahrgast =<- channelAlgPerson
  214.  
  215.  
  216. switch fahrgast.status {
  217. case 0: fahrgast.ist += 1
  218. fahrgast.wartezeit += 1
  219. case 11:
  220. if aufzug.event == "aufzug bereit"{
  221. fahrgast.status = 1 // fahrgast hat jetzt einen zielaufzug
  222. fahrgast.aufzugNr = aufzug.aufzugNr
  223. fahrgast.soll = fahrgast.ziel - fahrgast.start
  224. if fahrgast.soll < 0{
  225. fahrgast.soll = fahrgast.soll *-1 // negative werte umkehren
  226. }
  227. }else{
  228. fahrgast.ist += 1
  229. fahrgast.wartezeit += 1
  230. }
  231. case 1: fahrgast.ist += 1
  232. fahrgast.wartezeit += 1
  233. case 12:
  234. fahrgast.status = 2
  235. case 2: fahrgast.ist += 1
  236. case 23:
  237. fahrgast.status = 3 // fahrgast als ausgestiegen markieren
  238. fahrgast.abweichung = fahrgast.ist - fahrgast.soll
  239.  
  240. default:
  241.  
  242. }
  243. channelAlgAufzug2 <- aufzug
  244. channelAlgPerson2 <- fahrgast
  245.  
  246. //Stoppe Schleife
  247. select {
  248. case msg1 := <-doneChan:
  249. simuLaueft = msg1
  250. default:
  251. }
  252. }
  253.  
  254.  
  255. }
  256.  
  257. //------------------------------------------------------GOROUTINE AUFZUG------------------------------------------------------
  258.  
  259. func goroutineA(chanMitAufzug chan aufzugUndPerson,chanMitPerson chan aufzugUndPerson, chan bool){
  260.  
  261. simuLaueft:=true
  262. for simuLaueft{
  263. //aufzug := <- channelAlgAufzug
  264. //fahrgast := <- chanAntwortVonFahrgast
  265. var aufzug Aufzug
  266. var fahrgast Person
  267.  
  268. fahrgast = <-chanAntwortVonFahrgast
  269. aufzug =<- channelAlgAufzug
  270.  
  271.  
  272. switch aufzug.event {
  273. case "aufzug bereit":
  274. aufzug.zielEtage = fahrgast.start // aufzug erhält neues ziel
  275. case "aussteigen":
  276. //println("aussteigen")
  277. aufzug.fahrgaeste -= 1// anzahl der fahrgäste im Aufzug reduzieren
  278. case "einsteigen":
  279. //println("einsteigen")
  280. aufzug.fahrgaeste += 1
  281. case "anfrage unten":
  282. aufzug.etage -= 1
  283. aufzug.strecke += 1 // gesamtstrecke des aufzugs erhöhen
  284. case "anfrage oben":
  285. aufzug.etage += 1
  286. aufzug.strecke += 1 // gesamtstrecke des aufzugs erhöhen
  287. case "ziel unten":
  288. aufzug.etage -= 1
  289. aufzug.strecke += 1
  290. case "ziel oben":
  291. aufzug.etage += 1
  292. aufzug.strecke += 1
  293. }
  294. channelAlgAufzug2 <- aufzug
  295. channelAlgPerson2 <- fahrgast
  296.  
  297. select { //for i:=0;i<anz*dauer;i++{
  298. case msg1 := <-doneChan:
  299. simuLaueft = msg1
  300. default:
  301. }
  302. }
  303.  
  304.  
  305.  
  306. }
  307.  
  308.  
  309. //----------------------------------------------ALGORITHMUS------------------------------------------------------------------
  310.  
  311. //func Aufzugsteuerungs_Agorithmus_1 (channelAlgA, channelAuswertungAufzuege chan []Aufzug, channelAlgP,channelAuswertungPersonen chan []Person, maxPers, dauer)
  312.  
  313.  
  314. func Aufzugsteuerungs_Agorithmus_1 (aufzugUndPersonChan chan aufzugUndPerson,maxPers int, dauer int ,anz int){
  315. aufzugListe := make([]Aufzug,0)
  316. fahrgaesteListe := make([]Person,0)
  317.  
  318.  
  319. chanMitPerson:=make(chan aufzugUndPerson)
  320. chanMitAufzug:=make(chan aufzugUndPerson)
  321.  
  322.  
  323. chanDoneAuf:=make(chan bool,1)
  324. chanDonePerRoutine:=make(chan bool,1)
  325.  
  326.  
  327. aUp:=<-aufzugUndPersonChan
  328.  
  329. aufzugListe =aUp.a
  330. fahrgaesteListe = aUp.p
  331.  
  332. fmt.Println(aufzugListe)
  333. fmt.Println(fahrgaesteListe)
  334.  
  335. go goroutineP(chanMitPerson,chanMitAufzug,chanDonePerRoutine)
  336. go goroutineA(chanMitPerson,chanMitAufzug,chanDoneAuf)
  337.  
  338. for ; dauer >= 0; dauer--{
  339.  
  340. println("In der Schleife")
  341. antwort_fahrgast := <- chan_antwort_fahrgast
  342. antwort_aufzug := <- chan_antwort_aufzug
  343. fahrgaesteListe = append(fahrgaesteListe, antwort_fahrgast)
  344. aufzugListe = append(aufzugListe,antwort_aufzug)
  345.  
  346. for i := range aufzugListe {
  347. // planung
  348. if aufzugListe[i].fahrgaeste == 0{
  349. //aufzug leer? dann erhalte neue anfrage
  350. for k:= range fahrgaesteListe{
  351.  
  352. if fahrgaesteListe[k].status == 0{ // nehme ersten wartenden fahrgast
  353.  
  354. aufzugListe[i].event = "aufzug bereit"
  355. fahrgaesteListe[k].status = 11
  356. chanfahrgast <- fahrgaesteListe[k]
  357. chanaufzug <- aufzugListe[i]
  358. fahrgaesteListe = append(fahrgaesteListe[:k], fahrgaesteListe[k+1:]...)
  359. break
  360. }
  361. }
  362. }
  363.  
  364. // ausführung
  365. for j:= range fahrgaesteListe{
  366. //schritt: aussteigen lassen
  367. if aufzugListe[i].etage == fahrgaesteListe[j].ziel && fahrgaesteListe[j].status == 2 && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr{
  368.  
  369. println("Jemand ist ausgestiegen")
  370. aufzugListe[i].event = "aussteigen"
  371. fahrgaesteListe[j].status = 23
  372. //chanfahrgast <- fahrgaesteListe[j]
  373. //chanaufzug <- aufzugListe[i]
  374. fahrgaesteListe = append(fahrgaesteListe[:j], fahrgaesteListe[j+1:]...)
  375.  
  376. break
  377.  
  378. // schritt: einsteigen lassen
  379. }else if aufzugListe[i].etage == fahrgaesteListe[j].start && fahrgaesteListe[j].status == 1 && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr{
  380.  
  381. aufzugListe[i].event = "einsteigen"
  382. fahrgaesteListe[j].status = 12
  383. //chanfahrgast <- fahrgaesteListe[j]
  384. //chanaufzug <- aufzugListe[i]
  385. fahrgaesteListe = append(fahrgaesteListe[:j], fahrgaesteListe[j+1:]...)
  386.  
  387. break
  388.  
  389. //schritt: zu anfrage runter fahren
  390. }else if aufzugListe[i].etage > aufzugListe[i].zielEtage && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr && fahrgaesteListe[j].status == 1{ // aufzug runter fahren
  391.  
  392. aufzugListe[i].event = "anfrage unten"
  393. //fahrgaesteListe[j].status = 1
  394. //chanfahrgast <- fahrgaesteListe[j]
  395. //chanaufzug <- aufzugListe[i]
  396. fahrgaesteListe = append(fahrgaesteListe[:j], fahrgaesteListe[j+1:]...)
  397.  
  398. break
  399.  
  400. //schritt: zu anfrage rauf fahren
  401. }else if aufzugListe[i].etage < aufzugListe[i].zielEtage && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr && fahrgaesteListe[j].status == 1{ // aufzug rauf fahren
  402. aufzugListe[i].event = "anfrage oben"
  403. //fahrgaesteListe[j].status = 1
  404. chanfahrgast <- fahrgaesteListe[j]
  405. chanaufzug <- aufzugListe[i]
  406. fahrgaesteListe = append(fahrgaesteListe[:j], fahrgaesteListe[j+1:]...)
  407.  
  408.  
  409. break
  410. //schritt: zu ziel des gasts runter fahren
  411. }else if aufzugListe[i].etage > aufzugListe[i].zielEtage && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr && fahrgaesteListe[j].status == 2{
  412.  
  413. aufzugListe[i].event = "ziel unten"
  414. chanfahrgast <- fahrgaesteListe[j]
  415. chanaufzug <- aufzugListe[i]
  416. fahrgaesteListe = append(fahrgaesteListe[:j], fahrgaesteListe[j+1:]...)
  417.  
  418.  
  419. break
  420. //schritt: zu ziel des gasts rauf fahren
  421. }else if aufzugListe[i].etage < aufzugListe[i].zielEtage && aufzugListe[i].aufzugNr == fahrgaesteListe[j].aufzugNr && fahrgaesteListe[j].status == 2{
  422. aufzugListe[i].event = "ziel oben"
  423. chanfahrgast <- fahrgaesteListe[j]
  424. chanaufzug <- aufzugListe[i]
  425. fahrgaesteListe = append(fahrgaesteListe[:j], fahrgaesteListe[j+1:]...)
  426. break
  427. }
  428.  
  429.  
  430. }
  431.  
  432. }
  433. select{
  434. case msg1 := <- chan_antwort_fahrgast:
  435. fahrgaesteListe = append(fahrgaesteListe,msg1)
  436. case msg2 := <- chan_antwort_aufzug:
  437. aufzugListe = append(aufzugListe,msg2)
  438. default:
  439. }
  440.  
  441.  
  442. }
  443.  
  444.  
  445. chanDoneAuf<-false
  446. chanDonePerRoutine<-false
  447. aufzugUndPersonChan<-aufzugUndPerson{fahrgaesteListe,aufzugListe}
  448.  
  449. }
  450.  
  451. //}
  452.  
  453.  
  454. //----------------------------------------------------MAIN--------------------------------------------------
  455. func main(){
  456.  
  457. go ZentraleSteuerlogik()
  458. wgSimulationsEnde.Add(1) //Warte auf Simulationsende
  459. wgSimulationsEnde.Wait()
  460. println("Alles fertig")
  461.  
  462. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement