static void server_deleteByIdJSON(http_request_t request, socket_t* client, worker_t** workers)
{
int id;
char* getId = strpbrk(request.uri, "0123456");
if(getId)
{
id = atoi(getId);
if(id<0 || id>6 || worker_getId(workers[id]) == -1)
{
socket_write_string(client, "<h1>Wrong ID</h1><p><a href=\"/workers/\">All workers</a></p>");
return;
}
}
else
{
server_notFound(client);
return;
}
char toSend[2000];
char buffer[2000];
sprintf(buffer,
"Success!"
"Worker %s successfully deleted!", worker_getName(workers[id]));
workers[id] = worker_new();
sprintf(toSend,
"HTTP/1.1 200 OK\n"
"Content-Type: application/json\n"
"Content-Length: %i\r\n\r\n"
"\n%s", strlen(buffer), buffer);
socket_write_string(client, toSend);
socket_close(client);
}
/*
* queue_new:
*
* Create a new workload queue.
*
* Returns the newly created #Queue.
*/
Queue*
queue_new (void)
{
Queue* queue = g_slice_new0 (Queue);
gint thread;
gint n_threads = get_n_processors (); /* FIXME: make G_GNUC_CONST and put into loop argument? */
for (thread = 0; thread < n_threads; thread++) {
GError* error = NULL;
Worker* worker = worker_new (thread, &error);
if (!error) {
queue->threads = g_list_prepend (queue->threads, worker);
queue->idle_threads = g_list_prepend (queue->idle_threads, worker);
} else {
g_printerr ("error creating thread %d (%d of %d)\n",
worker->id, thread + 1, n_threads);
}
}
queue->threads = g_list_reverse (queue->threads);
queue->jobs = g_queue_new ();
return queue;
}
static void server_personalTask(http_request_t request, socket_t* client, db_t* base)
{
char salaryReq[10], salaryVal[10], yearReq[10], yearVal[10], toSend[10000];
char* str = strtok(request.uri, "?&=");
str = strtok(NULL, "?&=");
strcpy(salaryReq, str); // salary_m || salary_l
str = strtok(NULL, "?&=");
strcpy(salaryVal, str); // salary value
str = strtok(NULL, "?&=");
strcpy(yearReq, str); // year_m || year_l
str = strtok(NULL, "?&=");
strcpy(yearVal, str); // year value
int count = db_countWorkers(base);
worker_t** workers[count];
for(int i = 0; i<count; i++)
workers[i] = worker_new();
str = db_personalTask(base, salaryReq, atoi(salaryVal), yearReq, atoi(yearVal), workers);
sprintf(toSend,
"HTTP/1.1 200 OK\n"
"Content-Type: application/json\n"
"Content-Length: %i\r\n\r\n"
"\n%s", strlen(str)+1, str);
for(int i = 0; i<count; i++)
worker_free(workers[i]);
socket_write_string(client, toSend);
socket_close(client);
}
static char* server_getAllWorkersHTML(db_t* base)
{
char allOfTHem[10000] = "";
char one[1000];
int count = db_countWorkers(base);
worker_t** workers[count];
for(int i = 0; i<count; i++)
workers[i] = worker_new();
db_fillWorkerArr(base, workers);
for(int i = 0; i < count; i++)
{
sprintf(one,
" <p>Id: %i<br>"
" Name: <a href=\"/workers/%i\">%s</a><br>"
" <a href=\"/workers/delete/%i\">Free worker</a>"
" <br><br></p>",
worker_getId(workers[i]), worker_getId(workers[i]), worker_getName(workers[i]),
worker_getId(workers[i]));
strcat(allOfTHem, one);
}
strcat(allOfTHem, "<a href=\"/workers/new/\">New worker</a>");
for(int i = 0; i<count; i++)
worker_free(workers[i]);
return allOfTHem;
}
int main ()
{
float time = 0;
int valid = 1;
FILE *f = fopen ("asynclocklessresultsN", "a");
int n = 100;
N = 0;
while ((N+=1000) < 100000)
{
int i = 0;
time = 0;
while (i++ < 10){
clock_t t1, t2;
Data data;
SynchronisingThread *mainThread;
Worker **workers;
data.value = 0;
t1 = clock ();
mainThread = synchronising_thread_new (n, &data);
int a = synchronising_thread_start (mainThread);
if (a)
{
printf ("Error creating Main Thread");
}
workers = malloc (sizeof (Worker *) *n);
int i;
for (i = 0; i < n; i++)
{
workers[i] = worker_new (mainThread, i, worker_thread_func);
int ans = worker_start (workers[i]);
if (ans)
{
printf ("Error creating thread %d", i);
}
}
for (i = 0; i < n; i++)
{
worker_join (workers[i]);
free (workers[i]);
}
free (workers);
synchronising_thread_exit (mainThread, 1);
synchronising_thread_join (mainThread);
synchronising_thread_free (mainThread);
//free (mainThread);
t2 = clock ();
printf ("%d\n", data.value);
time += (((float)t2 - (float)t1) / 1000000.0 ) * 1000;
}
printf ("Timeout: %f for N: %d\n", time/i, N);
fprintf (f, "Timeout: %f for N: %d\n", time/i, N);
fflush (f);
}
fclose (f);
return 0;
}
static void getEventsForLastHour_NoOne_countZero(void ** state){
callback rc = reaction;
turniket_t turniket = turniket_create(rc);
worker_t worker1 = worker_new("Andrey Krysyuk", ALLOWED);
worker_t worker2 = worker_new("Olga Yashan", ALLOWED);
event_t event1 = event_new(worker1, 1000, INSIDE);
event_t event2 = event_new(worker2, 1200, INSIDE);
turniket_addEvent(turniket, event1);
turniket_addEvent(turniket, event2);
list_t * forLastHour = list_new();
int count = turniket_getEventsForLastHour(turniket, forLastHour, 1500);
assert_int_equal(count , 0);
turniket_delete(turniket);
event_delete(event1);
event_delete(event2);
worker_delete(worker1);
worker_delete(worker2);
}
static void getEventsForLastHour_fourEvents_countTwo(void ** state){
callback rc = reaction;
turniket_t turniket = turniket_create(rc);
worker_t worker1 = worker_new("Andrey Krysyuk", ALLOWED);
worker_t worker2 = worker_new("Olga Yashan", ALLOWED);
event_t event1 = event_new(worker1, 1230, INSIDE);
event_t event2 = event_new(worker2, 1200, INSIDE);
event_t event3 = event_new(worker1, 1250, OUTSIDE);
event_t event4 = event_new(worker2, 1255, OUTSIDE);
turniket_addEvent(turniket, event1);
turniket_addEvent(turniket, event2);
turniket_addEvent(turniket, event3);
turniket_addEvent(turniket, event4);
list_t * forLastHour = list_new();
int count = turniket_getEventsForLastHour(turniket, forLastHour, 1300);
assert_int_equal(count , 2);
turniket_delete(turniket);
event_delete(event1);
event_delete(event2);
event_delete(event3);
event_delete(event4);
}
struct server *
server_new(const char *cfg_file) {
int i;
struct server *s = calloc(1, sizeof(struct server));
s->cfg = conf_read(cfg_file);
/* workers */
s->w = calloc(s->cfg->http_threads, sizeof(struct worker*));
for(i = 0; i < s->cfg->http_threads; ++i) {
s->w[i] = worker_new(s);
}
return s;
}
server_t *server_new() {
server_t *s = (server_t *)zd_malloc(sizeof(server_t));
s->conn = NULL;
s->endpoints = array_new(sizeof(endpoint_t));
s->receivers = array_new(sizeof(receiver_t *));
s->workers = array_new(sizeof(worker_t *));
int i;
for (i = 0; i < 4; i++) {
worker_t *worker = worker_new();
worker->server = s;
array_push_back(s->workers, &worker);
}
s->curr_worker = 0;
return s;
}
gpointer worker_runParallel(WorkLoad* workload) {
utility_assert(workload);
/* get current thread's private worker object */
Worker* worker = worker_new(workload->slave);
/* continuously run all events for this worker's assigned nodes.
* the simulation is done when the engine is killed. */
while(!slave_isKilled(worker->slave)) {
SimulationTime barrier = slave_getExecutionBarrier(worker->slave);
guint nEventsProcessed = 0;
guint nNodesWithEvents = 0;
GList* item = workload->hosts;
while(item) {
Host* node = item->data;
guint n = _worker_processNode(worker, node, barrier);
nEventsProcessed += n;
if(n > 0) {
nNodesWithEvents++;
}
item = g_list_next(item);
}
slave_notifyProcessed(worker->slave, nEventsProcessed, nNodesWithEvents);
}
/* free all applications before freeing any of the nodes since freeing
* applications may cause close() to get called on sockets which needs
* other node information.
*/
GList* hosts = workload->hosts;
while(hosts) {
worker->cached_node = hosts->data;
host_freeAllApplications(worker->cached_node);
worker->cached_node = NULL;
hosts = hosts->next;
}
g_list_foreach(workload->hosts, (GFunc) host_free, NULL);
// g_thread_exit(NULL);
return NULL;
}
static struct db *_db_new(const char *directory)
{
struct db *db = malloc(sizeof(struct db));
memset(db, 0, sizeof(struct db));
db->log_fd = 2; /* stderr */
db->log_dir = dir_open(db, directory);
if (db->log_dir == NULL) {
free(db);
return NULL;
}
db->worker = worker_new(db);
if (db->worker == NULL) {
dir_free(db->log_dir);
free(db);
return NULL;
}
return db;
}
Slave* slave_new(Master* master, Configuration* config, guint randomSeed) {
Slave* slave = g_new0(Slave, 1);
MAGIC_INIT(slave);
g_mutex_init(&(slave->lock));
g_mutex_init(&(slave->pluginInitLock));
slave->master = master;
slave->config = config;
slave->random = random_new(randomSeed);
slave->rawFrequencyKHz = utility_getRawCPUFrequency(CONFIG_CPU_MAX_FREQ_FILE);
if(slave->rawFrequencyKHz == 0) {
info("unable to read '%s' for copying", CONFIG_CPU_MAX_FREQ_FILE);
}
slave->hosts = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
slave->programs = g_hash_table_new_full(g_int_hash, g_int_equal, NULL, (GDestroyNotify)program_free);
slave->dns = dns_new();
slave->nWorkers = (guint) configuration_getNWorkerThreads(config);
slave->mainThreadWorker = worker_new(slave);
slave->cwdPath = g_get_current_dir();
slave->dataPath = g_build_filename(slave->cwdPath, "shadow.data", NULL);
slave->hostsPath = g_build_filename(slave->dataPath, "hosts", NULL);
if(g_file_test(slave->dataPath, G_FILE_TEST_EXISTS)) {
gboolean success = utility_removeAll(slave->dataPath);
utility_assert(success);
}
gchar* templateDataPath = g_build_filename(slave->cwdPath, "shadow.data.template", NULL);
if(g_file_test(templateDataPath, G_FILE_TEST_EXISTS)) {
gboolean success = utility_copyAll(templateDataPath, slave->dataPath);
utility_assert(success);
}
g_free(templateDataPath);
return slave;
}
static char* server_getAllWorkersJSON(db_t* base)
{
char allOfTHem[4000] = "";
int count = db_countWorkers(base);
worker_t** workers[count];
for(int i = 0; i<count; i++)
workers[i] = worker_new();
db_fillWorkerArr(base, workers);
for(int i = 0; i < count; i++)
{
strcat(allOfTHem, worker_makeWorkerJSON(workers[i]));
}
for(int i = 0; i<count; i++)
worker_free(workers[i]);
return allOfTHem;
}
server *
server_new(conf *cfg, logger *log) {
int i;
server *s;
s = calloc(1, sizeof(server));
/* read cfg file */
s->cfg = cfg;
/* log */
s->log = log;
/* setup workers */
s->w = calloc(s->cfg->workers, sizeof(worker *));
for(i=0; i<s->cfg->workers; i++) {
s->w[i] = worker_new(s);
}
log_it(s->log, PULSAR_DEBUG, "workers initialized ...");
return s;
}
LPWORKER worker_pop (void)
{
LPWORKER lpWorkerFree = NULL;
WaitForSingleObject(hWorkersMutex, INFINITE);
/* Get the first worker of the list */
if (lpWorkers != NULL)
{
lpWorkerFree = lpWorkers;
lpWorkers = LIST_NEXT(LPWORKER, lpWorkers);
}
nWorkersCurrent++;
nWorkersMax = (nWorkersCurrent > nWorkersMax ? nWorkersCurrent : nWorkersMax);
#ifdef DBUG
dbug_print("Workers running current/runnning max/waiting: %d/%d/%d",
nWorkersCurrent,
nWorkersMax,
list_length((LPLIST)lpWorkers));
#endif
ReleaseMutex(hWorkersMutex);
if (lpWorkerFree == NULL)
{
/* We cannot find a free worker, create one. */
lpWorkerFree = worker_new();
}
/* Ensure that we don't get dangling pointer to old data. */
list_init((LPLIST)lpWorkerFree);
lpWorkerFree->lpJobUserData = NULL;
/* Reset events */
ResetEvent(lpWorkerFree->hJobStarted);
ResetEvent(lpWorkerFree->hJobStop);
ResetEvent(lpWorkerFree->hJobDone);
return lpWorkerFree;
}
static void server_post(http_request_t request, socket_t* client, db_t* base)
{
char buffer[2000] ="";
char* name = http_request_getArg(&request, "name");
char* surname = http_request_getArg(&request, "surname");
char* salary = http_request_getArg(&request, "salary");
char* year = http_request_getArg(&request, "year");
if(strlen(name) <= 1 || strlen(surname) <= 1)
{
server_send(client, "Name/Surname wasn't filled in"
"<p><a href=\"/workers/new/\">Back to POST</a></p>");
return;
}
if(isdigit(salary[0]) == 0 || isdigit(year[0])==0)
{
server_send(client, "Wrong data!"
"<p><a href=\"/workers/new/\">Back to POST</a></p>");
return;
}
if(salary == " ")
salary = "0";
if(year == " ")
year = "0";
worker_t* worker = worker_new();
worker_fill(worker, -1, name, surname, atoi(salary), atoi(year));
db_insertWorker(base, worker);
worker_free(worker);
server_send(client, "Success"
"<p><a href=\"/workers/\">All workers</a></p>");
}
// Function responsible for the workers on current TM node.
void *worker(void *ptr)
{
int my_rank = COMM_get_rank_id();
int task_id, j_id=0; // j_id = journal id for current thread.
struct tm_thread_data *d = (struct tm_thread_data *) ptr;
struct byte_array * task;
struct result_node * result;
uint64_t buffer;
struct j_entry * entry;
workerid = d->id;
void* (*worker_new) (int, char **);
worker_new = dlsym(d->handle, "spits_worker_new");
void (*execute_pit) (void *, struct byte_array *, struct byte_array *);
execute_pit = dlsym(d->handle, "spits_worker_run");
void* (*worker_free) (void *);
worker_free = dlsym(d->handle, "spits_worker_free");
void *user_data = worker_new ? worker_new(d->argc, d->argv) : NULL;
if(TM_KEEP_JOURNAL > 0) {
j_id = JOURNAL_get_id(d->dia, 'W');
}
sem_wait (&d->tcount); // wait for the first task to arrive.
while (d->running) {
pthread_mutex_lock(&d->tlock); // Get a new task.
cfifo_pop(&d->f, &task);
pthread_mutex_unlock(&d->tlock);
// Warn the Task Manager about the new space available.
sem_post(&d->sem);
byte_array_unpack64(task, &buffer);
task_id = (int) buffer;
debug("[worker] Received TASK %d", task_id);
//_byte_array_pack64(task, (uint64_t) task_id); // Put it back, might use in execute_pit.
result = (struct result_node *) malloc(sizeof(struct result_node));
byte_array_init(&result->ba, 10);
byte_array_pack64(&result->ba, task_id); // Pack the ID in the result byte_array.
byte_array_pack64(&result->ba, my_rank);
if(TM_KEEP_JOURNAL > 0) {
entry = JOURNAL_new_entry(d->dia, j_id);
entry->action = 'P';
gettimeofday(&entry->start, NULL);
}
debug("[--WORKER] task: %d", task);
debug("[--WORKER] &result->ba: %d", &result->ba);
execute_pit(user_data, task, &result->ba); // Do the computation.
if(TM_KEEP_JOURNAL > 0) {
gettimeofday(&entry->end, NULL);
}
byte_array_free(task); // Free memory used in task and pointer.
free(task); // For now, each pointer is allocated in master thread.
debug("Appending task %d.", task_id);
pthread_mutex_lock(&d->rlock); // Pack the result to send it later.
result->next = d->results;
result->before = NULL;
result->task_id = task_id;
if(d->results != NULL) {
d->results->before = result;
}
d->results = result;
if(d->is_blocking_flush==1) {
if(TM_NO_WAIT_FINAL_FLUSH > 0) {
sem_post(&d->no_wait_sem);
}
else {
d->bf_remaining_tasks--;
if(d->bf_remaining_tasks==0) {
pthread_mutex_unlock(&d->bf_mutex);
}
}
}
pthread_mutex_unlock(&d->rlock);
sem_wait (&d->tcount); // wait for the next task to arrive.
}
if (worker_free) {
worker_free(user_data);
}
//free(result);
pthread_exit(NULL);
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static HINSTANCE hInst;
static HWND hButtonEx, hLable;
static HWND hStaticIndS, hStaticNameS, hStaticSurnameS, hStaticExpS, hStaticSalarS;
static HWND hStaticName, hStaticSurname, hStaticExp, hStaticSalar;
static worker_t * worker[WORKERS_COUNT];
static int index;
static char buffer[10];
static int tick;
switch(msg)
{
case WM_CREATE:
CreateWindowW(
L"button",
L"Timer",
WS_CHILD|WS_VISIBLE|BS_CHECKBOX|BS_AUTOCHECKBOX,
90, 150, 130, 23,
hwnd,
(HMENU)TIMER_CB,
NULL,
NULL);
hButtonEx = CreateWindowEx(0,
WC_BUTTON,
"Exit",
WS_CHILD|WS_VISIBLE|WS_TABSTOP|BS_DEFPUSHBUTTON,
90, 190, 130, 23,
hwnd,
(HMENU)BUTTON_EX,
hInst,
NULL);
hStaticIndS = CreateWindowEx(0,
WC_STATIC,
"Index:",
WS_CHILD|WS_VISIBLE,
10, 20, 130, 23,
hwnd,
(HMENU)STATIC_INDEX_S,
hInst,
NULL);
hStaticNameS = CreateWindowEx(0,
WC_STATIC,
"Name:",
WS_CHILD|WS_VISIBLE,
10, 44, 130, 23,
hwnd,
(HMENU)STATIC_NAME_S,
hInst,
NULL);
hStaticSurnameS = CreateWindowEx(0,
WC_STATIC,
"Surname:",
WS_CHILD|WS_VISIBLE,
10, 68, 130, 23,
hwnd,
(HMENU)STATIC_SURNAME_S,
hInst,
NULL);
hStaticExpS = CreateWindowEx(0,
WC_STATIC,
"Experience:",
WS_CHILD|WS_VISIBLE,
10, 92, 130, 23,
hwnd,
(HMENU)STATIC_EXP_S,
hInst,
NULL);
hStaticSalarS = CreateWindowEx(0,
WC_STATIC,
"Salary:",
WS_CHILD|WS_VISIBLE,
10, 116, 130, 23,
hwnd,
(HMENU)STATIC_SALARY_S,
hInst,
NULL);
index = rand() % WORKERS_COUNT;
worker[0] = worker_new(0, "George", "Horn", 6, 6000);
worker[1] = worker_new(1, "Emily", "Wiggins", 2, 2000);
worker[2] = worker_new(2, "Claude", "Jefferson", 3, 3000);
worker[3] = worker_new(3, "Ursula", "Miller", 1, 1000);
worker[4] = worker_new(4, "Damian", "Fields", 4, 4500);
tick = worker_getIndex(worker[index]);
hLable = CreateWindowEx(0,
"STATIC",
itoa(worker_getIndex(worker[index]), buffer, 10),
WS_CHILD|WS_VISIBLE,
150, 20, 130, 23,
hwnd,
(HMENU)LABLE_ID,
hInst,
NULL);
int ret = SetTimer(hwnd, TIMER_CB, TIMER_TICK, NULL);
if(ret == 0)
MessageBox(hwnd, "Could not set timer", "ERROR", MB_OK|MB_ICONEXCLAMATION);
hStaticName = CreateWindowEx(0,
WC_STATIC,
worker_getName(worker[index]),
WS_CHILD|WS_VISIBLE,
150, 44, 130, 23,
hwnd,
(HMENU)STATIC_NAME,
hInst,
NULL);
hStaticSurname = CreateWindowEx(0,
WC_STATIC,
worker_getSurname(worker[index]),
WS_CHILD|WS_VISIBLE,
150, 68, 130, 23,
hwnd,
(HMENU)STATIC_SURNAME,
hInst,
NULL);
hStaticExp = CreateWindowEx(0,
WC_STATIC,
itoa(worker_getExp(worker[index]), buffer, 10),
WS_CHILD|WS_VISIBLE,
150, 92, 130, 23,
hwnd,
(HMENU)STATIC_EXP,
hInst,
NULL);
hStaticSalar = CreateWindowEx(0,
WC_STATIC,
itoa(worker_getSalary(worker[index]), buffer, 10),
WS_CHILD|WS_VISIBLE,
150, 116, 130, 23,
hwnd,
(HMENU)STATIC_SALARY,
hInst,
NULL);
break;
case WM_TIMER:
{
int checked = IsDlgButtonChecked(hwnd, TIMER_CB);
if(checked)
{
tick++;
sprintf(buffer, "%i", tick);
HWND hIndex = GetDlgItem(hwnd, LABLE_ID);
SendMessage(hIndex, WM_SETTEXT, (WPARAM)256, (LPARAM)buffer);
}
}
break;
case WM_COMMAND:
{
switch(LOWORD(wParam))
{
case BUTTON_EX:
{
for(int i = 0; i<WORKERS_COUNT; i++)
worker_free(worker[i]);
DestroyWindow(hwnd);
break;
}
}
break;
}
case WM_CLOSE:
for(int i = 0; i<WORKERS_COUNT; i++)
worker_free(worker[i]);
DestroyWindow(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
}
