Exemple #1
0
	std::wstring render(bool propper, std::wstring syntax, std::wstring date_format = DATE_FORMAT, DWORD langId = 0) const {
		if (propper) {
			// To obtain the appropriate message string from the message file, load the message file with the LoadLibrary function and use the FormatMessage function
			strEx::replace(syntax, _T("%message%"), render_message(langId));
		} else {
			strEx::replace(syntax, _T("%message%"), _T("%message% needs the descriptions flag set!"));
		}

		strEx::replace(syntax, _T("%source%"), get_source());
		strEx::replace(syntax, _T("%computer%"), get_computer());
		strEx::replace(syntax, _T("%generated%"), strEx::format_date(get_time_generated(), date_format));
		strEx::replace(syntax, _T("%written%"), strEx::format_date(get_time_written(), date_format));
		strEx::replace(syntax, _T("%generated-raw%"), strEx::itos(pevlr_->TimeGenerated));
		strEx::replace(syntax, _T("%written-raw%"), strEx::itos(pevlr_->TimeWritten));
		strEx::replace(syntax, _T("%type%"), translateType(eventType()));
		strEx::replace(syntax, _T("%category%"), strEx::itos(pevlr_->EventCategory));
		strEx::replace(syntax, _T("%facility%"), strEx::itos(facility()));
		strEx::replace(syntax, _T("%qualifier%"), strEx::itos(facility()));
		strEx::replace(syntax, _T("%customer%"), strEx::itos(customer()));
		strEx::replace(syntax, _T("%rawid%"), strEx::itos(raw_id()));
		strEx::replace(syntax, _T("%severity%"), translateSeverity(severity()));
		strEx::replace(syntax, _T("%strings%"), enumStrings());
		strEx::replace(syntax, _T("%log%"), file_);
		strEx::replace(syntax, _T("%file%"), file_);
		strEx::replace(syntax, _T("%id%"), strEx::itos(eventID()));
		strEx::replace(syntax, _T("%user%"), userSID());
		return syntax;
	}
Exemple #2
0
void init(){
	/* Initialize two facilities to represent servers. */
	f1 = facility("facility 1");
	f2 = facility("facility 2");
	
	/* Initialize an event to signal simulation completion */
	done = event("done");
	
	/* Initialize some boxes for bookkeeping. */
	queue_box = box("queue");
	queue_box2 = box("queue 2");
	service_box = box("in service");
	service_box2 = box("in service 2");
}
Exemple #3
0
 boost::optional<ModelObject> Building_Impl::facilityAsModelObject() const {
   OptionalModelObject result;
   OptionalFacility intermediate = facility();
   if (intermediate) {
     result = *intermediate;
   }
   return result;
 }
Exemple #4
0
int main (int argc, char*argv[]) {
	static int 	n,	/* # de nodos */
			token,
			event,
			r,
			i;
	static char fa_name[5];

	if (argc != 2) {
		printf("Uso incorreto. Sintaxe: '%s <# de nodos>'\n",argv[0]);
		exit(1);
	}

	n=atoi(argv[1]);
	smpl(0,"um exemplo de simulacao");
	reset();
	stream(1);
	
	/* INICIALIZACAO */
	nodo = (tnodo*) malloc(sizeof(tnodo)*n);
	for (i=0;i<n;i++) {
		memset(fa_name, 0, 5);
		sprintf(fa_name,"%d",i);
		nodo[i].id = facility(fa_name,1);
		/* Aqui inicializa as variáveis locais */
	}
	
	/* escalonamento ds eventos */
	for (i=0; i<n; i++)
		schedule(test,30.0,i);
	schedule(fault,50.0,2);
	schedule(repair,80.0,2);
	
	while(time() < 100) {
		cause(&event,&token);
		switch(event) {
			case test:
				if(status(nodo[token].id) != 0) break;
				printf("O nodo %d vai estar no tempo %5.1f\n",token,time());
				schedule(test,30.0,token);
				break;
			case fault:
				r=request(nodo[token].id,token,0);
				if(r!=0) {
					printf("Nao foi possivel falhar o nodo %d\n",token);
					exit(1);
				}
				printf("O nodo %d falhou no tempo %5.1f\n", token, time());
				break;
			case repair:
				printf("O nodo %d se recuperou no tempo %5.1f\n", token, time());
				release(nodo[token].id,token);
				schedule(test,30.0,token);
				break;
		}
	}
}
Exemple #5
0
static void
usageerror()
{
    char msg[] = "\
    ex1_initiator [-c callingTitle][-d FAC][-m maxPDU][-t title][-v] node port\n\
    \n\
    -c    Set calling AE title to callingTitle in Association RQ\n\
    -d    Place one facility(DCM, DUL, SRV) in verbose mode\n\
    -m    Set maximum PDU in Association RQ to maxPDU\n\
    -t    Set called AE title to title in Association RQ\n\
    -v    Place DUL and SRV facilities in verbose mode\n\
    \n\
    node  Node name for network connection\n\
    port  TCP / IP port number of server application\n";

    fprintf(stderr, msg);
    exit(1);
}
Exemple #6
0
/**
 * Create process list
 * @param pnum Number of processes in the system
 * @return List of processes of the system
 */
process init_processes(int pnum)
{
    process plist = malloc(sizeof(struct process_t) * pnum);

    if (plist == NULL) return NULL;

    for(int i = 0; i < pnum; ++i) {
        plist[i].state = ST_RELEASED;
        plist[i].timestamp = 0;
        plist[i].request_timestamp = 0;
        plist[i].recv_queue = facility("recvq", 2 * pnum);
        plist[i].recvd_from = create_pqueue(2 * pnum);
        plist[i].nreplies = 0;
        plist[i].pending = malloc(sizeof(int) * pnum);
        memset(plist[i].pending, 0, sizeof(int) * pnum);
    }

    return plist;
}
Exemple #7
0
int main(int argc, char *argv[]){
  static int N, /* Numero de nodos */
    token,
    event,
    teste,
    r, i;

  static char fa_name[5]; /* Facility Name */
  char *fail_code[2] = {"Sem falha", "Falho"};

  if(argc != 2){
    printf("USO: %s num_nodos\n", argv[0]);
    exit(1);
  }

  N = atoi(argv[1]);
  smpl(0, "Um Exemplo");
  reset();
  stream(1);

  /* Inicializacao */

  nodo = (Tnodo*) malloc(sizeof(Tnodo)*N);
  for(i = 0; i < N; i++){
    memset(fa_name, "\0", 5);
    sprintf(fa_name, "%d", i);
    nodo[i].id = facility(fa_name, 1);
    nodo[i].stats = -1;
    /* Aqui inicializa as variaveis locais */
  }

  /* Escalonamento de eventos */

  for(i=0; i<N; i++){
    schedule(test, 30.0, i);
  }

  schedule(fault, 50.0, 2); /* O nodo 2 vai falhar em 50.0 */
  schedule(fault, 50.0, 3);
  schedule(fault, 50.0, 4);
  schedule(repair, 100.0, 2);


  while(time() < 200){
    cause(&event, &token);
    switch(event){
    case test:

      if(status(nodo[token].id) != 0)
        break;

      teste = status(nodo[(token+1)%N].id);
      i = 1;
      while(teste){
        teste = status(nodo[(token+i)%N].id);
        if(!teste == 0){
          nodo[token].stats = (token+i)%N;
          i++;
        }
      }

      printf("%5.1f - O nodo %d testou o nodo %d. Resultado: %s\n",
             time(), token, (token+i)%N,
             fail_code[teste], nodo[token].stats);
      schedule(test, 30.0, token);

      break;

    case fault:
      r = request(nodo[token].id, token, 0);
      if(r != 0){
        puts("Nao foi possivel falhar o nodo\n");
        exit(1);
      }
      printf("%5.1f - O nodo %d falhou\n", time(), token);
      break;

    case repair:
      printf("%5.1f - O nodo %d recuperou\n", time(), token);
      release(nodo[token].id, token);
      schedule(test, 30.0, token);
      break;

    }
  }
  return 0;
}
 boost::optional<ParentObject> ExteriorLights_Impl::parent() const {
   return facility();
 }
 boost::optional<ModelObject> ExteriorLights_Impl::facilityAsModelObject() const {
   OptionalModelObject result = facility();
   return result;
 }
Exemple #10
0
/* Program body */
int main(int argc, char *argv[]) {
    static int N; 
    static int token;
    static int event;
    static int sender;
    static int timestamp;
    static int r;
    static int i;
    static int delay;
    static char fa_name[5];

    int scheduled_events = 0;

    if (argc < 2) {
        show_usage();
        exit(1);
    }

    // Number of nodes    
    N = argc-1;

    // Sets up SMPL simulation
    smpl(0, "mutual exclusion");
    reset();
    stream(1); // 1 execution thread

    // Node intialization
    nodes = (Node*) malloc(N*sizeof(Node));
    int times[N];
    for (i=0; i<N; i++) {
        memset (fa_name, '\0', 5);
        sprintf(fa_name, "%d", i);
        nodes[i].id = facility(fa_name, 1);
        nodes[i].running = false;
        nodes[i].clock = 0;
        nodes[i].pending = (bool *) malloc(N*sizeof(bool));
        memset (nodes[i].pending, false, N*sizeof(bool));

        nodes[i].waiting_reply = 0;

        times[i] = atoi(argv[i+1]);

        // Timestamp -1 means that the node has no active request
        nodes[i].timestamp = -1;
    }

    // Schedules the critical region requests
    for (i=0; i<N; i++) {
        schedule (REQUEST, times[i], i, i, 0);
        scheduled_events++;
    }

    printf("=============================================================================\n");
    printf("               Ricart-Agrawala mutual exclusion algorithm                    \n");
    printf("               Renan Greca - Distributed Systems, May 2016                   \n");
    printf("=============================================================================\n");

    // The program keeps running while there are still events scheduled
    while (scheduled_events > 0) {
        printf("-----\n");
        cause(&event, &token, &sender, &timestamp);
        switch(event) {
            case REQUEST:
                // REQUEST critical region access to other nodes
                scheduled_events--;

                nodes[token].clock++;
                printf("(%d, %d) Requested C.R. \n", token, nodes[token].clock);
                // Stores timestamp of request for priority reference
                nodes[token].timestamp = nodes[token].clock;

                // Sends requests to all other nodes
                for (i=0; i<N; i++) {
                    if (i==token) {
                        continue;
                    }
                    delay = rand_int(0, MAX_MESSAGE_DELAY);
                    // Sends REQUEST message to node i with a random delay
                    schedule (RECEIVE_REQUEST, delay, i, token, nodes[token].clock);
                    scheduled_events++;
                    nodes[token].waiting_reply++;

                }

                break;

            case RECEIVE_REQUEST:
                // Receive and handle a REQUEST
                scheduled_events--;

                // Updates logical clock
                nodes[token].clock = (nodes[token].clock > timestamp ? nodes[token].clock : timestamp)+1;
                printf("(%d, %d) Received request from %d\n", token, nodes[token].clock, sender);

                // Checks whether the sender node has priority over the receiver
                if (priority(sender, token, timestamp, nodes[token].timestamp) && !nodes[token].running) {
                    // If the sender has priority, send a REPLY
                    delay = rand_int(0, MAX_MESSAGE_DELAY);
                    printf("(%d, %d) Sending reply to %d\n", token, nodes[token].clock, sender);
                    schedule(RECEIVE_REPLY, delay, sender, token, nodes[token].clock);
                    scheduled_events++;
                } else {
                    // Else, store it in the pending array
                    printf("(%d, %d) Adding %d to pending array\n", token, nodes[token].clock, sender);
                    nodes[token].pending[sender] = true;
                }

                break;

            case RECEIVE_REPLY:
                // Receive and handle a REPLY
                scheduled_events--;

                // Updates logical clock
                nodes[token].clock = (nodes[token].clock > timestamp ? nodes[token].clock : timestamp)+1;
                printf("(%d, %d) Received reply from %d\n", token, nodes[token].clock, sender);
                
                nodes[token].waiting_reply--;
                // If node received all replies, it enters the critical region
                if (nodes[token].waiting_reply == 0) {
                    printf("(%d, %d) Entered the critical region.\n", token, nodes[token].clock);
                    schedule (RELEASE, RUNNING_INTERVAL, token, token, nodes[token].clock);
                    scheduled_events++;
                    nodes[token].running = true;
                }
                
                break;

            case RELEASE:
                // Release the critical region and alert other nodes
                scheduled_events--;
                
                nodes[token].clock++;
                printf("(%d, %d) Left the critical region.\n", token, nodes[token].clock);
                
                // Clear the information of the previous request
                nodes[token].running = false;
                nodes[token].timestamp = -1;

                // Send all pending REPLIES
                for (i=0; i<N; i++) {
                    if (nodes[token].pending[i]) {
                        delay = rand_int(0, MAX_MESSAGE_DELAY);
                        printf("(%d, %d) Sending reply to %d\n", token, nodes[token].clock, i);
                        schedule(RECEIVE_REPLY, delay, i, token, nodes[token].clock);
                        scheduled_events++;
                        nodes[token].pending[i] = false;
                    }
                }
                
                break;
        }
    }

}
Exemple #11
0
/* Program body */
int main(int argc, char *argv[]) {
	static int N; // Number of nodes
	static int token;
	static int event;
	static int r;
	static int i;
	static char fa_name[5];
	
	if (argc != 2) {
		puts("Uso correto: tempo [num-nodos]");
		exit(1);
	}
	
	N = atoi(argv[1]);
	smpl(0, "programa tempo");
	reset();
	stream(1); // 1 execution thread
	
	// Node intialization
	nodes = (Node*) malloc(N*sizeof(Node));
	for (i=0; i<N; i++) {
		memset (fa_name, '\0', 5);
		sprintf(fa_name, "%d", i);
		nodes[i].id = facility(fa_name, 1);
	}
	
	for (i=0; i<N; i++) {
		schedule (TEST, 30.0, i);
	}
	schedule (FAULT, 31.0, 2);
	schedule (REPAIR, 61.0, 2);
	
	while (time() < 100.0) {
		cause(&event, &token);
		switch(event) {
			case TEST:
				if(status(nodes[token].id != 0)) {
					break;
				}
				printf("Sou o nodo %d, vou testar no tempo %5.1f\n", token, time());
				printf("\n");
				schedule(TEST, 30.0, token);
				break;
			case FAULT:
				r = request(nodes[token].id, token, 0);
				if (r != 0) {
					puts("Não consegui falhar o nodo!");
					exit(1);
				}
				printf("Sou o nodo %d, falhei no tempo %5.1f\n", token, time());


				break;
			case REPAIR:
				release(nodes[token].id, token);
				printf("Sou o nodo %d, recuperei no tempo %5.1f\n", token, time());

				schedule(TEST, 30.0, token);
				break;
		}
	}
}
//=============================================================================
//==  Main program                                                           ==
//=============================================================================
void sim(int argc, char *argv[])
{
  double   lambda;      // Mean arrival rate (cust/sec)
  double   mu;          // Mean service rate (cust/sec)
  double   offered_load;

  // Create the simulation
  create("sim");

  // Output usage
  if (argc != 2)
  {
    printf("Usage: 'offered_load' - offered_load between 0 and 1 \n");
    return;
  }
  offered_load = atof(argv[1]);
  assert((offered_load > 0.0) && (offered_load < 1.0));

  // CSIM initializations
  Server1 = facility("Server1");
  Server2 = facility("Server2");
  Server3 = facility("Server3");
  Server4 = facility("Server4");
  Server5 = facility("Server5");
  Resp_table = table("Response time table");

  // Parameter initializations
  mu = 1.0;
  lambda = offered_load * (double)5;

  // Output begin-of-simulation banner
  printf("*** BEGIN SIMULATION *** \n");

  // Initiate generate function and hold for SIM_TIME
  generate(lambda, mu);
  hold(SIM_TIME);

  // Output results
  printf("============================================================= \n");
  printf("==   *** CSIM 5 x M/M/1 queueing system simulation ***     == \n");
  printf("============================================================= \n");
  printf("= Lambda               = %6.3f cust/sec   \n", lambda);
  printf("= Mu (for each server) = %6.3f cust/sec   \n", mu);
  printf("============================================================= \n");
  printf("= Total CPU time     = %6.3f sec      \n", cputime());
  printf("= Total sim time     = %6.3f sec      \n", clock);
  printf("= Total completions  = %ld cust       \n",
    (completions(Server1) + completions(Server2) + completions(Server3) + completions(Server4) + completions(Server5)));
  printf("=------------------------------------------------------------ \n");
  printf("= >>> Simulation results                                    - \n");
  printf("=------------------------------------------------------------ \n");
  printf("= Utilization 1        = %6.3f %%       \n", 100.0 * util(Server1));
  printf("= Mean num in system 1 = %6.3f cust     \n", qlen(Server1));
  printf("= Mean response time 1 = %6.3f sec      \n", resp(Server1));
  printf("= Mean service time 1  = %6.3f sec      \n", serv(Server1));
  printf("= Mean throughput 1    = %6.3f cust/sec \n", tput(Server1));
  printf("=------------------------------------------------------------ \n");
  printf("= Utilization 2        = %6.3f %%       \n", 100.0 * util(Server2));
  printf("= Mean num in system 2 = %6.3f cust     \n", qlen(Server2));
  printf("= Mean response time 2 = %6.3f sec      \n", resp(Server2));
  printf("= Mean service time 2  = %6.3f sec      \n", serv(Server2));
  printf("= Mean throughput 2    = %6.3f cust/sec \n", tput(Server2));
  printf("=------------------------------------------------------------ \n");
  printf("= Utilization 3        = %6.3f %%       \n", 100.0 * util(Server3));
  printf("= Mean num in system 3 = %6.3f cust     \n", qlen(Server3));
  printf("= Mean response time 3 = %6.3f sec      \n", resp(Server3));
  printf("= Mean service time 3  = %6.3f sec      \n", serv(Server3));
  printf("= Mean throughput 3    = %6.3f cust/sec \n", tput(Server3));
  printf("=------------------------------------------------------------ \n");
  printf("= Utilization 4        = %6.3f %%       \n", 100.0 * util(Server4));
  printf("= Mean num in system 4 = %6.3f cust     \n", qlen(Server4));
  printf("= Mean response time 4 = %6.3f sec      \n", resp(Server4));
  printf("= Mean service time 4  = %6.3f sec      \n", serv(Server4));
  printf("= Mean throughput 4    = %6.3f cust/sec \n", tput(Server4));
  printf("=------------------------------------------------------------ \n");
  printf("= Utilization 5        = %6.3f %%       \n", 100.0 * util(Server5));
  printf("= Mean num in system 5 = %6.3f cust     \n", qlen(Server5));
  printf("= Mean response time 5 = %6.3f sec      \n", resp(Server5));
  printf("= Mean service time 5  = %6.3f sec      \n", serv(Server5));
  printf("= Mean throughput 5    = %6.3f cust/sec \n", tput(Server5));
  printf("=------------------------------------------------------------ \n");
  printf("& Table mean for response time = %6.3f sec   \n",
    table_mean(Resp_table));
  printf("============================================================= \n");

  // Output end-of-simulation banner
  printf("*** END SIMULATION *** \n");
  getchar();
}