M/VisualSapfor
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed code style, removed unnecessary pragmas

Browse Source
This commit is contained in:
Alexander
2023-12-03 13:09:16 +03:00
parent bd74d4684f
commit 6b7bde1471
12 changed files with 765 additions and 744 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
Planner/Array.h
View File

@@ -1,42 +1,44 @@
#pragma once
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#pragma once
template <class T> template <class T>
class Array { class Array {
protected: protected:
long length; long length;
T** elements; T** elements;
public: public:
Array(){ Array() {
length=0; length = 0;
elements=NULL; elements = NULL;
} }
virtual ~Array(){ virtual ~Array() {
if (elements !=NULL){ if (elements != NULL) {
for (long i=0; i<length; ++i) for (long i = 0; i < length; ++i)
delete elements[i]; delete elements[i];
delete [] elements; delete[] elements;
} }
} }
void add(T * new_line) { void add(T* new_line) {
T ** buf = new T*[length + 1]; T** buf = new T * [length + 1];
for (long i = 0; i < length; ++i) { for (long i = 0; i < length; ++i) {
buf[i] = elements[i]; buf[i] = elements[i];
} }
buf[length] = new_line; buf[length] = new_line;
length++; length++;
delete[] elements; delete[] elements;
elements = buf; elements = buf;
buf = NULL; buf = NULL;
} }
long getLength(){ long getLength() {
return length; return length;
} }
T * get(long i){ T* get(long i) {
return elements[i]; return elements[i];
} }
T** getElements(){ T** getElements() {
return elements; return elements;
} }
}; };

24
Planner/CompilationSupervisor.h
View File

@@ -1,20 +1,22 @@
#pragma once
#include "Supervisor.h" #include "Supervisor.h"
#include "CompilationTask.h" #include "CompilationTask.h"
#pragma once
class CompilationSupervisor: public Supervisor<CompilationTask> { class CompilationSupervisor : public Supervisor<CompilationTask> {
public: public:
CompilationSupervisor(){ CompilationSupervisor() {
this->init("compilationTasks", 4); this->init("compilationTasks", 4);
} }
CompilationTask * getTaskById(long task_id){ CompilationTask* getTaskById(long task_id) {
for (long i=0; i< length; ++i){ for (long i = 0; i < length; ++i) {
CompilationTask * task = get(i); CompilationTask* task = get(i);
if (task->getId()==task_id) if (task->getId() == task_id)
return task; return task;
} }
return NULL; return NULL;
} }
virtual String getStatePrefix(){ virtual String getStatePrefix() {
return String("Compilation"); return String("Compilation");
} }
}; };

91
Planner/CompilationTask.h
View File

@@ -1,47 +1,50 @@
#include "Task.h"
#pragma once #pragma once
class CompilationTask: public Task {
String test_id; #include "Task.h"
String makefile_text; #include "Text.h"
public:
void setTestId(String * test_id_in){ class CompilationTask : public Task {
test_id = String(test_id_in->getCharArray()); String test_id;
} String makefile_text;
void setMakefileText(String * makefile_text_in){ public:
makefile_text = String(makefile_text_in->getCharArray(), '|'); void setTestId(String* test_id_in) {
} test_id = String(test_id_in->getCharArray());
virtual void print(){ }
printf("id=%ld; maxtime=%d; test_id=%s\n", id, maxtime, void setMakefileText(String* makefile_text_in) {
test_id.getCharArray()); makefile_text = String(makefile_text_in->getCharArray(), '|');
printf("makefile_text=%s\n", makefile_text.getCharArray()); }
} virtual void print() {
CompilationTask(Text * lines, int offset):Task(lines,offset) { printf("id=%ld; maxtime=%d; test_id=%s\n", id, maxtime,
setTestId(lines->get(offset+2)); test_id.getCharArray());
setMakefileText(lines->get(offset+3)); printf("makefile_text=%s\n", makefile_text.getCharArray());
setState(Waiting); }
kernels=1; CompilationTask(Text* lines, int offset) :Task(lines, offset) {
} setTestId(lines->get(offset + 2));
setMakefileText(lines->get(offset + 3));
virtual void prepareWorkspace(){ setState(Waiting);
String makeFilePath = String(id)+"/Makefile"; kernels = 1;
File makeFileFile = File(makeFilePath, this->makefile_text); }
String tests = userWorkspace+"/projects";
String testPath= tests+"/"+test_id; virtual void prepareWorkspace() {
String copyCommand = "cp -r " + String::DQuotes(testPath + "/.") + " "+ String::DQuotes(workspace); String makeFilePath = String(id) + "/Makefile";
system(copyCommand.getCharArray()); File makeFileFile = File(makeFilePath, this->makefile_text);
} String tests = userWorkspace + "/projects";
virtual String getLaunchScriptText(){ String testPath = tests + "/" + test_id;
String modules = userWorkspace+"/modules"; String copyCommand = "cp -r " + String::DQuotes(testPath + "/.") + " " + String::DQuotes(workspace);
String starterCall = modules+"/starter"; system(copyCommand.getCharArray());
String launcherCall = modules+"/launcher"; }
return String::DQuotes(starterCall)+" "+ virtual String getLaunchScriptText() {
String::DQuotes(launcherCall)+" "+ String modules = userWorkspace + "/modules";
String(maxtime)+" "+ String starterCall = modules + "/starter";
String::DQuotes("")+" "+ String launcherCall = modules + "/launcher";
"make -j -f Makefile"; return String::DQuotes(starterCall) + " " +
} String::DQuotes(launcherCall) + " " +
virtual void analyseResults(){ String(maxtime) + " " +
String binary = workspace+"/0"; String::DQuotes("") + " " +
state = Utils::Exists(binary)? Done:DoneWithErrors; "make -j -f Makefile";
}
virtual void analyseResults() {
String binary = workspace + "/0";
state = Utils::Exists(binary) ? Done : DoneWithErrors;
} }
}; };

126
Planner/File.h
View File

@@ -1,64 +1,66 @@
#include "Text.h"
#pragma once #pragma once
class File {
FILE* ptr; #include "Text.h"
public: class File {
File(String* name) { FILE* ptr;
ptr = fopen(name->getCharArray(), "r"); public:
} File(String* name) {
File(const char * name) { ptr = fopen(name->getCharArray(), "r");
ptr = fopen(name, "r"); }
} File(const char* name) {
File(const String& name, const String& text){ ptr = fopen(name, "r");
ptr = fopen(name.getCharArray(), "w"); }
fprintf(ptr, "%s\n", text.getCharArray()); File(const String& name, const String& text) {
} ptr = fopen(name.getCharArray(), "w");
~File() { fprintf(ptr, "%s\n", text.getCharArray());
if (ptr != NULL) { }
fclose(ptr); ~File() {
ptr = NULL; if (ptr != NULL) {
} fclose(ptr);
} ptr = NULL;
Text* readLines(){ }
Text* lines = new Text(); }
int c; Text* readLines() {
String * line = NULL; Text* lines = new Text();
bool lineStarted = false; int c;
do { String* line = NULL;
c = fgetc(ptr); bool lineStarted = false;
if (lineStarted){ do {
switch (c) { c = fgetc(ptr);
case '\r': if (lineStarted) {
break; switch (c) {
case '\n': case '\r':
case EOF: break;
lines->add(line); case '\n':
line = NULL; case EOF:
lineStarted = false; lines->add(line);
break; line = NULL;
default: lineStarted = false;
line->addChar((char)c); break;
break; default:
} line->addChar((char)c);
}else { break;
switch (c){ }
case '\r': }
break; else {
case '\n': switch (c) {
line = new String(); case '\r':
lines->add(line); break;
line = NULL; case '\n':
break; line = new String();
case EOF: lines->add(line);
break; line = NULL;
default: break;
line = new String(); case EOF:
line->addChar((char)c); break;
lineStarted = true; default:
break; line = new String();
} line->addChar((char)c);
} lineStarted = true;
}while (c!=EOF); break;
return lines; }
} }
} while (c != EOF);
return lines;
}
}; };

11
Planner/Global.h
View File

@@ -1,13 +1,10 @@
#pragma once
#include "String.h" #include "String.h"
#pragma once
String userWorkspace; String userWorkspace;
#pragma once
String packageWorkspace; String packageWorkspace;
#pragma once
int maxKernels; int maxKernels;
#pragma once
int busyKernels; int busyKernels;
#pragma once
int freeKernels; int freeKernels;
#pragma once String dvm_drv;
String dvm_drv;

40
Planner/RunSupervisor.h
View File

@@ -1,31 +1,33 @@
#pragma once
#include "CompilationSupervisor.h" #include "CompilationSupervisor.h"
#include "RunTask.h" #include "RunTask.h"
#pragma once
class RunSupervisor: public Supervisor<RunTask> { class RunSupervisor : public Supervisor<RunTask> {
public: public:
RunSupervisor(CompilationSupervisor * compilationSupervisor){ RunSupervisor(CompilationSupervisor* compilationSupervisor) {
this->init("runTasks", 8); this->init("runTasks", 8);
//проверить отмененные задачи. //проверить отмененные задачи.
for (long i=0; i< this->length; ++i){ for (long i = 0; i < this->length; ++i) {
RunTask * task = this->get(i); RunTask* task = this->get(i);
CompilationTask * parent = compilationSupervisor->getTaskById( task->getTestCompilationTaskId()); CompilationTask* parent = compilationSupervisor->getTaskById(task->getTestCompilationTaskId());
task->setState((parent->getState()==Done)?Waiting:Canceled); task->setState((parent->getState() == Done) ? Waiting : Canceled);
task->setParent(parent); task->setParent(parent);
printf("id=%ld; parent_id = %ld; state=%s\n", printf("id=%ld; parent_id = %ld; state=%s\n",
task->getId(), task->getId(),
task->getParent()->getId(), task->getParent()->getId(),
task->printState().getCharArray()); task->printState().getCharArray());
} }
} }
virtual String getStatePrefix(){ virtual String getStatePrefix() {
return String("Running"); return String("Running");
} }
virtual void Finalize(){ virtual void Finalize() {
this->state = Archivation; this->state = Archivation;
saveState(); saveState();
printf("Archivation started\n"); printf("Archivation started\n");
Utils::ZipFolder(String("./"),String("archive.zip")); Utils::ZipFolder(String("./"), String("archive.zip"));
printf("Archivation ended\n"); printf("Archivation ended\n");
} }
}; };

180
Planner/RunTask.h
View File

@@ -1,94 +1,96 @@
#pragma once
#include "CompilationTask.h" #include "CompilationTask.h"
#pragma once
class RunTask : public Task { class RunTask : public Task {
long testcompilationtask_id; long testcompilationtask_id;
String binary_name; String binary_name;
String matrix; String matrix;
String environments; String environments;
String usr_par; String usr_par;
String args; String args;
CompilationTask* parent; CompilationTask* parent;
public: public:
virtual void print(){ virtual void print() {
printf("id=%ld; maxtime=%d; testcompilationtask_id=%ld; matrix=%s; environments=%s; usr_par=%s; args=%s kernels=%d\n", printf("id=%ld; maxtime=%d; testcompilationtask_id=%ld; matrix=%s; environments=%s; usr_par=%s; args=%s kernels=%d\n",
id, id,
maxtime, maxtime,
testcompilationtask_id, testcompilationtask_id,
matrix.getCharArray(), matrix.getCharArray(),
environments.getCharArray(), environments.getCharArray(),
usr_par.getCharArray(), usr_par.getCharArray(),
args.getCharArray(), args.getCharArray(),
kernels kernels
); );
} }
int setKernels(String * kernels_s){ int setKernels(String* kernels_s) {
return kernels = atoi(kernels_s->getCharArray()); return kernels = atoi(kernels_s->getCharArray());
}
long setTestCompilationTaskId(String * id_s){
return testcompilationtask_id=strtol(id_s->getCharArray(), NULL, 10);
}
long getTestCompilationTaskId(){
return testcompilationtask_id;
}
void setMatrix(String * matrix_in){
matrix= String (matrix_in->getCharArray());
}
void setEnvironments(String * environments_in){
environments= String(environments_in->getCharArray());
}
void setUsrPar(String * usr_par_in){
usr_par= String(usr_par_in->getCharArray(),'|');
}
void setArgs(String * args_in){
args= String(args_in->getCharArray());
} }
void setParent(CompilationTask * parent_in){ long setTestCompilationTaskId(String* id_s) {
parent = parent_in; return testcompilationtask_id = strtol(id_s->getCharArray(), NULL, 10);
binary_name = "spf_"+ String(id)+"_"+matrix.Replace(' ','_'); }
} long getTestCompilationTaskId() {
CompilationTask * getParent(){ return testcompilationtask_id;
return parent; }
} void setMatrix(String* matrix_in) {
RunTask(Text * lines, int offset):Task(lines,offset) { matrix = String(matrix_in->getCharArray());
setTestCompilationTaskId(lines->get(offset+2)); }
setMatrix(lines->get(offset+3)); void setEnvironments(String* environments_in) {
setEnvironments(lines->get(offset+4)); environments = String(environments_in->getCharArray());
setUsrPar(lines->get(offset+5)); }
setArgs(lines->get(offset+6)); void setUsrPar(String* usr_par_in) {
setKernels(lines->get(offset+7)); usr_par = String(usr_par_in->getCharArray(), '|');
} }
void setArgs(String* args_in) {
virtual String getLaunchScriptText(){ args = String(args_in->getCharArray());
String modules = userWorkspace+"/modules"; }
String starterCall = modules+"/starter"; void setParent(CompilationTask* parent_in) {
String launcherCall = modules+"/launcher"; parent = parent_in;
binary_name = "spf_" + String(id) + "_" + matrix.Replace(' ', '_');
}
CompilationTask* getParent() {
return parent;
}
RunTask(Text* lines, int offset) :Task(lines, offset) {
setTestCompilationTaskId(lines->get(offset + 2));
setMatrix(lines->get(offset + 3));
setEnvironments(lines->get(offset + 4));
setUsrPar(lines->get(offset + 5));
setArgs(lines->get(offset + 6));
setKernels(lines->get(offset + 7));
}
virtual String getLaunchScriptText() {
String modules = userWorkspace + "/modules";
String starterCall = modules + "/starter";
String launcherCall = modules + "/launcher";
//- //-
String dvm_start = String::DQuotes(dvm_drv) + " run "; String dvm_start = String::DQuotes(dvm_drv) + " run ";
if (!matrix.isEmpty()) if (!matrix.isEmpty())
dvm_start = dvm_start+matrix + " "; dvm_start = dvm_start + matrix + " ";
dvm_start = dvm_start+ String::DQuotes("./" + binary_name); dvm_start = dvm_start + String::DQuotes("./" + binary_name);
if (!args.isEmpty()) if (!args.isEmpty())
dvm_start = dvm_start+ " " + args; dvm_start = dvm_start + " " + args;
return String::DQuotes(starterCall)+" "+ return String::DQuotes(starterCall) + " " +
String::DQuotes(launcherCall)+" "+ String::DQuotes(launcherCall) + " " +
String(maxtime)+" "+ String(maxtime) + " " +
String::DQuotes("killall -SIGKILL " + binary_name)+" "+ String::DQuotes("killall -SIGKILL " + binary_name) + " " +
dvm_start; dvm_start;
}
virtual void prepareWorkspace(){
String binary_src = parent->getWorkspace()+"/0";
String binary_dst = workspace+"/"+binary_name;
Utils::Copy(binary_src, binary_dst);
if (!usr_par.isEmpty()){
String parPath = String(id)+"/usr.par";
File parFile = File(parPath, usr_par);
}
}
virtual String getStartCommand(){
String res = workspace+"/run";
if (!environments.isEmpty())
res = environments+" "+res;
printf("START %ld: %s\n", id, res.getCharArray());
return res;
} }
}; virtual void prepareWorkspace() {
String binary_src = parent->getWorkspace() + "/0";
String binary_dst = workspace + "/" + binary_name;
Utils::Copy(binary_src, binary_dst);
if (!usr_par.isEmpty()) {
String parPath = String(id) + "/usr.par";
File parFile = File(parPath, usr_par);
}
}
virtual String getStartCommand() {
String res = workspace + "/run";
if (!environments.isEmpty())
res = environments + " " + res;
printf("START %ld: %s\n", id, res.getCharArray());
return res;
}
};

403
Planner/String.h
View File

@@ -1,220 +1,223 @@
#pragma once
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <ctype.h> #include <ctype.h>
#pragma once
class String { class String {
friend String operator+(const String& a, const String& b); friend String operator+(const String& a, const String& b);
long length; long length;
char* body; char* body;
public: public:
String() { String() {
length = 0; length = 0;
body = new char[1]; body = new char[1];
body[0] = '\0'; body[0] = '\0';
} }
String(const char* s) { String(const char* s) {
length = strlen(s); length = strlen(s);
body = new char[length + 1]; body = new char[length + 1];
for (long i = 0; i < length; ++i) for (long i = 0; i < length; ++i)
body[i] = s[i]; body[i] = s[i];
body[length]='\0'; body[length] = '\0';
} }
String(const char* s, char ps) { String(const char* s, char ps) {
length = strlen(s); length = strlen(s);
body = new char[length + 1]; body = new char[length + 1];
for (long i = 0; i < length; ++i){ for (long i = 0; i < length; ++i) {
body[i] = (s[i]==ps)? '\n': s[i]; body[i] = (s[i] == ps) ? '\n' : s[i];
} }
body[length]='\0'; body[length] = '\0';
} }
~String() { ~String() {
if (body != NULL) { if (body != NULL) {
delete[] body; delete[] body;
} }
} }
void println() const{ void println() const {
printf("[%s]\n", body); printf("[%s]\n", body);
} }
void addChar(char c) { void addChar(char c) {
char* buf = new char[length + 2]; char* buf = new char[length + 2];
for (long i = 0; i < length; ++i) { for (long i = 0; i < length; ++i) {
buf[i] = body[i]; buf[i] = body[i];
} }
buf[length] = c; buf[length] = c;
length++; length++;
//-- //--
buf[length] = '\0'; buf[length] = '\0';
delete[] body; delete[] body;
body = buf; body = buf;
buf = NULL; buf = NULL;
} }
char * getCharArray() const{ char* getCharArray() const {
return body; return body;
} }
String (int s){ String(int s) {
length = 0; length = 0;
body = new char[1]; body = new char[1];
body[0] = '\0'; body[0] = '\0';
if (s>=0){ if (s >= 0) {
int s_ = s; int s_ = s;
int size = 1; int size = 1;
while (s_>=10){ while (s_ >= 10) {
s_ = s_/10; s_ = s_ / 10;
size++; size++;
} }
length = size; length = size;
body = new char [size+1]; body = new char[size + 1];
sprintf(body, "%d", s); sprintf(body, "%d", s);
} }
} }
String (long s){ String(long s) {
length = 0; length = 0;
body = new char[1]; body = new char[1];
body[0] = '\0'; body[0] = '\0';
if (s>=0){ if (s >= 0) {
long s_ = s; long s_ = s;
long size = 1; long size = 1;
while (s_>=10){ while (s_ >= 10) {
s_ = s_/10; s_ = s_ / 10;
size++; size++;
} }
length = size; length = size;
body = new char [size+1]; body = new char[size + 1];
sprintf(body, "%ld", s); sprintf(body, "%ld", s);
} }
} }
const String& operator=(const String& s){ const String& operator=(const String& s) {
if (body != NULL) if (body != NULL)
delete[] body; delete[] body;
length = s.length; length = s.length;
body = new char[length+1]; body = new char[length + 1];
for (long i=0; i<length; ++i) for (long i = 0; i < length; ++i)
body[i]=s.body[i]; body[i] = s.body[i];
body[length]='\0'; body[length] = '\0';
return *this; return *this;
} }
static String DQuotes(const String& s){ static String DQuotes(const String& s) {
String res;
res.length = s.length+2;
res.body=new char[res.length+1];
res.body[0] = '"';
res.body[res.length-1] = '"';
res.body[res.length] = '\0';
for (long i=0; i< s.length; ++i)
res.body[i+1]=s.body[i];
return res;
}
String Replace(char f, char t){
String res;
res.length = length;
res.body = new char[length];
res.body[length]='\0';
for (long i = 0; i < length; ++i)
res.body[i]= (body[i]==f)? t: body[i];
return res;
}
String Remove(char f){
String res; String res;
for (long i=0; i<length; ++i){ res.length = s.length + 2;
if (body[i]!=f) res.body = new char[res.length + 1];
res.body[0] = '"';
res.body[res.length - 1] = '"';
res.body[res.length] = '\0';
for (long i = 0; i < s.length; ++i)
res.body[i + 1] = s.body[i];
return res;
}
String Replace(char f, char t) {
String res;
res.length = length;
res.body = new char[length];
res.body[length] = '\0';
for (long i = 0; i < length; ++i)
res.body[i] = (body[i] == f) ? t : body[i];
return res;
}
String Remove(char f) {
String res;
for (long i = 0; i < length; ++i) {
if (body[i] != f)
res.addChar(body[i]); res.addChar(body[i]);
} }
return res; return res;
} }
bool isEmpty() const{ bool isEmpty() const {
return length==0; return length == 0;
} }
bool contains(const String& s) const{ bool contains(const String& s) const {
bool res = false; bool res = false;
bool search_on=false; bool search_on = false;
if (s.isEmpty()) return true; if (s.isEmpty()) return true;
if (s.length>length) return false; if (s.length > length) return false;
long k=0; long k = 0;
long start=-1; long start = -1;
for (long i=0; i<length; ++i){ for (long i = 0; i < length; ++i) {
if (search_on){ if (search_on) {
if (k<s.length){ if (k < s.length) {
if (body[i]==s.body[k]){ if (body[i] == s.body[k]) {
k++; k++;
}else { }
else {
//обрыв поиска. //обрыв поиска.
search_on =false; search_on = false;
k=0; k = 0;
start=-1; start = -1;
} }
} }
else { else {
//printf("starts with %ld", start); //printf("starts with %ld", start);
return true; return true;
} }
}else { }
if (body[i]== s.body[0]){ else {
k=1; if (body[i] == s.body[0]) {
start=i; k = 1;
search_on=true; start = i;
search_on = true;
//printf("search started %d\n", start); //printf("search started %d\n", start);
} }
} }
} }
if (search_on) { if (search_on) {
//printf("starts with %ld\n", start); //printf("starts with %ld\n", start);
res=true; res = true;
} }
return res; return res;
} }
String toUpper(){ String toUpper() {
String res = String(this->getCharArray()); String res = String(this->getCharArray());
for (long i=0; i<length; ++i) for (long i = 0; i < length; ++i)
res.body[i]= toupper(body[i]); res.body[i] = toupper(body[i]);
res.println(); res.println();
return res; return res;
} }
long getLength(){ long getLength() {
return length; return length;
} }
bool operator==(const String&s) const { bool operator==(const String& s) const {
if (length!=s.length) return false; if (length != s.length) return false;
for (long i=0; i<length; ++i){ for (long i = 0; i < length; ++i) {
if (body[i]!=s.body[i]) return false; if (body[i] != s.body[i]) return false;
} }
return true; return true;
} }
/* регистр. /* регистр.
#include <stdio.h> #include <stdio.h>
#include <ctype.h> #include <ctype.h>
int main(void) { int main(void) {
FILE * f; FILE * f;
int c; int c;
if ( ! ( f = fopen("file.txt", "r") ) ) if ( ! ( f = fopen("file.txt", "r") ) )
return -1; return -1;
while ( ( c = fgetc(f) ) != EOF ) while ( ( c = fgetc(f) ) != EOF )
putchar( isupper(c) ? tolower(c) : toupper(c) ); putchar( isupper(c) ? tolower(c) : toupper(c) );
return ( fclose(f) ); return ( fclose(f) );
} }
*/ */
};
};
String operator+(const String& a, const String& b){ String operator+(const String& a, const String& b) {
String res = String(); String res = String();
res.length =a.length+b.length; res.length = a.length + b.length;
res.body = new char[res.length+1]; res.body = new char[res.length + 1];
for (long i=0; i<a.length; ++i) for (long i = 0; i < a.length; ++i)
res.body[i]=a.body[i]; res.body[i] = a.body[i];
for (long i=0; i<b.length; ++i) for (long i = 0; i < b.length; ++i)
res.body[i+a.length]=b.body[i]; res.body[i + a.length] = b.body[i];
res.body[res.length]='\0'; res.body[res.length] = '\0';
return res; return res;
} }

216
Planner/Supervisor.h
View File

@@ -1,8 +1,9 @@
#pragma once
#include <unistd.h>
#include "File.h" #include "File.h"
#include "Task.h" #include "Task.h"
#include <unistd.h>
#pragma once
enum SupervisorState { enum SupervisorState {
WorkspacesCreation, //0 WorkspacesCreation, //0
Preparation, //1 Preparation, //1
@@ -10,120 +11,121 @@ enum SupervisorState {
Archivation, //3 Archivation, //3
End //4 End //4
}; };
#pragma once
template <class T> template <class T>
class Supervisor : public Array <T> { class Supervisor : public Array <T> {
protected: protected:
SupervisorState state; SupervisorState state;
public: public:
virtual String getStatePrefix(){ virtual String getStatePrefix() {
return String(""); return String("");
} }
String printState(){ String printState() {
switch(state){ switch (state) {
case WorkspacesCreation: case WorkspacesCreation:
return String("WorkspacesCreation"); return String("WorkspacesCreation");
case Preparation: case Preparation:
return String("Preparation"); return String("Preparation");
case Execution: case Execution:
return String("Execution"); return String("Execution");
case Archivation: case Archivation:
return String("Archivation"); return String("Archivation");
case End: case End:
return String("End"); return String("End");
default: default:
return "?"; return "?";
} }
} }
//- //-
void print(){ void print() {
for (long i=0; i< this->length; ++i) for (long i = 0; i < this->length; ++i)
this->elements[i]->print(); this->elements[i]->print();
} }
void init(const char * fileName, int recordSize){ void init(const char* fileName, int recordSize) {
state = WorkspacesCreation; state = WorkspacesCreation;
File * packedTasks = new File(fileName); File* packedTasks = new File(fileName);
Text * lines = packedTasks->readLines(); Text* lines = packedTasks->readLines();
this->length = lines->getLength()/recordSize; this->length = lines->getLength() / recordSize;
this->elements = new T* [this->length]; this->elements = new T * [this->length];
int offset=0; int offset = 0;
for (int i=0; i< this->length; ++i){ for (int i = 0; i < this->length; ++i) {
this->elements[i]= new T(lines, offset); this->elements[i] = new T(lines, offset);
offset+=recordSize; offset += recordSize;
} }
delete packedTasks; delete packedTasks;
delete lines; delete lines;
} }
void Do(){ void Do() {
saveState(); saveState();
long activeCount=0; long activeCount = 0;
//todo обязательно убрать отладочную печать. //todo обязательно убрать отладочную печать.
printf("tasks count = %ld\n", this->length); printf("tasks count = %ld\n", this->length);
while (this->state!= End){ while (this->state != End) {
// printf("state=%d\n", this->state); // printf("state=%d\n", this->state);
// printf("max=%d; busy=%d; free=%d\n", maxKernels, busyKernels, freeKernels); // printf("max=%d; busy=%d; free=%d\n", maxKernels, busyKernels, freeKernels);
activeCount=0; activeCount = 0;
for (long i=0; i<this->length; ++i){ for (long i = 0; i < this->length; ++i) {
T * task = this->elements[i]; T* task = this->elements[i];
switch (this->state){ switch (this->state) {
case WorkspacesCreation: case WorkspacesCreation:
if (task->getState()==Waiting){ if (task->getState() == Waiting) {
activeCount++; activeCount++;
task->createWorkspace(); task->createWorkspace();
task->setState(WorkspaceCreated); task->setState(WorkspaceCreated);
} }
break; break;
case Preparation: case Preparation:
if (task->getState()==WorkspaceCreated){ if (task->getState() == WorkspaceCreated) {
activeCount++; activeCount++;
task->prepareWorkspace(); task->prepareWorkspace();
task->createLaunchScript(); task->createLaunchScript();
task->setState(WorkspaceReady); task->setState(WorkspaceReady);
} }
break; break;
case Execution: case Execution:
if (task->getState()==WorkspaceReady){ if (task->getState() == WorkspaceReady) {
activeCount++; activeCount++;
task->Start(); task->Start();
}else if (task->getState()==Running){ }
activeCount++; else if (task->getState() == Running) {
task->Check(); activeCount++;
} task->Check();
break; }
default: break;
// printf("id = %ld; state = %d\n", task->getId(), task->getState()); default:
break; // printf("id = %ld; state = %d\n", task->getId(), task->getState());
} break;
} }
// printf("active count = %d\n", activeCount); }
if (activeCount==0){ // printf("active count = %d\n", activeCount);
switch (this->state){ if (activeCount == 0) {
case WorkspacesCreation: switch (this->state) {
this->state = Preparation; case WorkspacesCreation:
saveState(); this->state = Preparation;
break; saveState();
case Preparation: break;
this->state = Execution; case Preparation:
saveState(); this->state = Execution;
break; saveState();
case Execution: break;
Finalize(); case Execution:
this->state = End; Finalize();
saveState(); this->state = End;
break; saveState();
default: break;
this->state = End; default:
break; this->state = End;
} break;
} }
Utils::Sleep(2); }
} Utils::Sleep(2);
} }
virtual void Finalize(){} }
void saveState(){ virtual void Finalize() {}
void saveState() {
Utils::Sleep(1); //чтобы не было одинаковых по дате файлов. Utils::Sleep(1); //чтобы не было одинаковых по дате файлов.
String stateFile = packageWorkspace+"/state/"+getStatePrefix()+printState(); String stateFile = packageWorkspace + "/state/" + getStatePrefix() + printState();
//printf("stateFile=<%s>\n", stateFile.getCharArray()); //printf("stateFile=<%s>\n", stateFile.getCharArray());
File(stateFile, Utils::getDate()); File(stateFile, Utils::getDate());
} }
}; };

264
Planner/Task.h
View File

@@ -1,9 +1,10 @@
#pragma once
#include "File.h" #include "File.h"
#include "Utils.h" #include "Utils.h"
#include "Global.h" #include "Global.h"
#pragma once enum TaskState {
enum TaskState {
Inactive, //0 Inactive, //0
Waiting, //1 Waiting, //1
WorkspaceCreated, //2 WorkspaceCreated, //2
@@ -24,140 +25,141 @@ enum TaskState {
NoSuchTask, //17 NoSuchTask, //17
FailedToQueue, //18 FailedToQueue, //18
AbortingByUser //19 AbortingByUser //19
}; };
#pragma once
enum TestType{ enum TestType {
Default, //0 Default, //0
Correctness, //1 Correctness, //1
Performance, //2 Performance, //2
}; };
#pragma once class Task {
class Task { protected:
protected: long id;
long id; int maxtime;
int maxtime;
int kernels; //получение зависит от типа задачи. int kernels; //получение зависит от типа задачи.
String workspace; String workspace;
TaskState state; TaskState state;
public: public:
String printState(){ String printState() {
switch(state){ switch (state) {
case Inactive: case Inactive:
return String("Inactive"); return String("Inactive");
case Waiting: case Waiting:
return String("Waiting"); return String("Waiting");
case WorkspaceCreated: case WorkspaceCreated:
return String("WorkspaceCreated"); return String("WorkspaceCreated");
case WorkspaceReady: case WorkspaceReady:
return String("WorkspaceReady"); return String("WorkspaceReady");
case Running: case Running:
return String("Running"); return String("Running");
case Canceled: case Canceled:
return String("Canceled"); return String("Canceled");
case Finished: case Finished:
return String("Finished"); return String("Finished");
case FinishedAbortedByTimeout: case FinishedAbortedByTimeout:
return String("FinishedAbortedByTimeout"); return String("FinishedAbortedByTimeout");
case FinishedAbortedByUser: case FinishedAbortedByUser:
return String("FinishedAbortedByUser"); return String("FinishedAbortedByUser");
case Done: case Done:
return String("Done"); return String("Done");
case DoneWithErrors: case DoneWithErrors:
return String("DoneWithErrors"); return String("DoneWithErrors");
case AbortedByTimeout: case AbortedByTimeout:
return String("AbortedByTimeout"); return String("AbortedByTimeout");
case AbortedByUser: case AbortedByUser:
return String("AbortedByUser"); return String("AbortedByUser");
case Crushed: case Crushed:
return String("Crushed"); return String("Crushed");
case WrongTestFormat: case WrongTestFormat:
return String("WrongTestFormat"); return String("WrongTestFormat");
case InternalError: case InternalError:
return String("InternalError"); return String("InternalError");
case Queued: case Queued:
return String("Queued"); return String("Queued");
case NoSuchTask: case NoSuchTask:
return String("NoSuchTask"); return String("NoSuchTask");
case FailedToQueue: case FailedToQueue:
return String("FailedToQueue"); return String("FailedToQueue");
case AbortingByUser: case AbortingByUser:
return String("AbortingByUser"); return String("AbortingByUser");
default: default:
return "?"; return "?";
} }
}
//-------------->>
long getId(){return id;}
long setId(String * id_s){
return id=strtol(id_s->getCharArray(), NULL, 10);
}
int getMaxtime(){return maxtime;}
int setMaxtime(String * maxtime_s){
return maxtime=atoi(maxtime_s->getCharArray());
}
const String& getWorkspace(){return workspace;}
TaskState getState(){return state;}
TaskState setState(TaskState state_in){return state=state_in;}
Task(Text * lines, int offset){
setId(lines->get(offset));
setMaxtime(lines->get(offset+1));
workspace = packageWorkspace+"/"+String(id);
}
virtual void print()=0;
//-
virtual void prepareWorkspace(){}
virtual String getLaunchScriptText()=0;
virtual String getStartCommand(){
return workspace+"/run";
}
void createWorkspace(){
Utils::Mkdir(workspace);
}
void createLaunchScript(){
String launchScriptPath = workspace+"/run";
String launchScriptText =
String("cd ")+String::DQuotes(workspace)+"\n"+
getLaunchScriptText();
File launchScriptFile = File(launchScriptPath, launchScriptText);
Utils::Chmod(launchScriptPath);
}
virtual void Start(){
if (kernels<=freeKernels){
system(getStartCommand().getCharArray());
state=Running;
//-
busyKernels= Utils::min(busyKernels+kernels, maxKernels);
freeKernels= Utils::max(0, maxKernels-busyKernels);
//-
}
}
virtual void analyseResults(){
state=Finished;
} }
virtual void Check(){ //-------------->>
if (Utils::Exists(workspace+"/DONE")){ long getId() { return id; }
analyseResults(); long setId(String* id_s) {
}else { return id = strtol(id_s->getCharArray(), NULL, 10);
if (Utils::Exists(workspace+"/TIMEOUT")){ }
state=AbortedByTimeout; int getMaxtime() { return maxtime; }
//todo определить по интервалу времени на всякий случай. int setMaxtime(String* maxtime_s) {
}else if (Utils::Exists(workspace+"/INTERRUPT")){ return maxtime = atoi(maxtime_s->getCharArray());
state=AbortedByUser; }
} const String& getWorkspace() { return workspace; }
} TaskState getState() { return state; }
if (state!=Running){ TaskState setState(TaskState state_in) { return state = state_in; }
Task(Text* lines, int offset) {
setId(lines->get(offset));
setMaxtime(lines->get(offset + 1));
workspace = packageWorkspace + "/" + String(id);
}
virtual void print() = 0;
//-
virtual void prepareWorkspace() {}
virtual String getLaunchScriptText() = 0;
virtual String getStartCommand() {
return workspace + "/run";
}
void createWorkspace() {
Utils::Mkdir(workspace);
}
void createLaunchScript() {
String launchScriptPath = workspace + "/run";
String launchScriptText =
String("cd ") + String::DQuotes(workspace) + "\n" +
getLaunchScriptText();
File launchScriptFile = File(launchScriptPath, launchScriptText);
Utils::Chmod(launchScriptPath);
}
virtual void Start() {
if (kernels <= freeKernels) {
system(getStartCommand().getCharArray());
state = Running;
//- //-
busyKernels= Utils::min(busyKernels-kernels, maxKernels); busyKernels = Utils::min(busyKernels + kernels, maxKernels);
freeKernels= Utils::max(0, maxKernels-busyKernels); freeKernels = Utils::max(0, maxKernels - busyKernels);
//-
}
}
virtual void analyseResults() {
state = Finished;
}
virtual void Check() {
if (Utils::Exists(workspace + "/DONE")) {
analyseResults();
}
else {
if (Utils::Exists(workspace + "/TIMEOUT")) {
state = AbortedByTimeout;
//todo определить по интервалу времени на всякий случай.
}
else if (Utils::Exists(workspace + "/INTERRUPT")) {
state = AbortedByUser;
}
}
if (state != Running) {
//-
busyKernels = Utils::min(busyKernels - kernels, maxKernels);
freeKernels = Utils::max(0, maxKernels - busyKernels);
//- //-
saveState(); //не нужно. только для отладки. анализ будет делаться архивом. saveState(); //не нужно. только для отладки. анализ будет делаться архивом.
} }
} }
virtual void saveState(){ virtual void saveState() {
String stateFile = workspace+"/TaskState"; String stateFile = workspace + "/TaskState";
File(stateFile, printState()); File(stateFile, printState());
} }
}; };

38
Planner/Text.h
View File

@@ -1,25 +1,27 @@
#pragma once
#include "String.h" #include "String.h"
#include "Array.h" #include "Array.h"
#pragma once
class Text: public Array<String> { class Text : public Array<String> {
public: public:
void Print(){ void Print() {
printf("text length=%ld\n", length); printf("text length=%ld\n", length);
for (long i=0; i<length; ++i){ for (long i = 0; i < length; ++i) {
printf("i=%ld; [%s]\n",i, elements[i]->getCharArray()); printf("i=%ld; [%s]\n", i, elements[i]->getCharArray());
// elements[i]->println(); // elements[i]->println();
}
}
bool hasMatch(const String& s) {
for (long i = 0; i < length; ++i) {
if (s.contains(*elements[i])) {
//printf("match: [%s]\n", elements[i]->getCharArray());
return true;
}
} }
}
bool hasMatch(const String& s){
for (long i=0; i<length; ++i){
if (s.contains(*elements[i])){
//printf("match: [%s]\n", elements[i]->getCharArray());
return true;
}
}
//printf("no matches for [%s]\n", s.getCharArray()); //printf("no matches for [%s]\n", s.getCharArray());
return false; return false;
} }
}; };

66
Planner/Utils.h
View File

@@ -1,49 +1,51 @@
#pragma once
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <errno.h> #include <errno.h>
#include <unistd.h> #include <unistd.h>
#include <time.h> #include <time.h>
#include "String.h" #include "String.h"
#pragma once
class Utils { class Utils {
public: public:
static int max(int a, int b){ static int max(int a, int b) {
return (a > b)? a:b; return (a > b) ? a : b;
}
static int min(int a, int b){
return (a > b)? b:a;
} }
static void Mkdir(const String& path){ static int min(int a, int b) {
return (a > b) ? b : a;
}
static void Mkdir(const String& path) {
mkdir(path.getCharArray(), 0777); mkdir(path.getCharArray(), 0777);
} }
//https://stackoverflow.com/questions/4568681/using-chmod-in-a-c-program //https://stackoverflow.com/questions/4568681/using-chmod-in-a-c-program
static void Chmod(const String& path){ static void Chmod(const String& path) {
String command = "chmod 777 "+String::DQuotes(path); String command = "chmod 777 " + String::DQuotes(path);
system(command.getCharArray()); system(command.getCharArray());
} }
//https://stackoverflow.com/questions/230062/whats-the-best-way-to-check-if-a-file-exists-in-c //https://stackoverflow.com/questions/230062/whats-the-best-way-to-check-if-a-file-exists-in-c
static bool Exists(const String& path){ static bool Exists(const String& path) {
struct stat buffer; struct stat buffer;
return (stat (path.getCharArray(), &buffer) == 0); return (stat(path.getCharArray(), &buffer) == 0);
} }
static void Sleep(int s){ static void Sleep(int s) {
usleep(s* 1000000); usleep(s * 1000000);
}
static void Copy(const String& src, const String& dst){
String command = "cp "+String::DQuotes(src)+" "+String::DQuotes(dst);
system(command.getCharArray());
} }
static long getAbsoluteTime(){ static void Copy(const String& src, const String& dst) {
return time (NULL); String command = "cp " + String::DQuotes(src) + " " + String::DQuotes(dst);
}
static String getDate(){
long int ttime;
ttime = time (NULL);
String res(ctime (&ttime));
return res;
}
static void ZipFolder(const String& src, const String& dst){
String command = "zip -r "+String::DQuotes(dst)+" "+String::DQuotes(src);
system(command.getCharArray()); system(command.getCharArray());
} }
}; static long getAbsoluteTime() {
return time(NULL);
}
static String getDate() {
long int ttime;
ttime = time(NULL);
String res(ctime(&ttime));
return res;
}
static void ZipFolder(const String& src, const String& dst) {
String command = "zip -r " + String::DQuotes(dst) + " " + String::DQuotes(src);
system(command.getCharArray());
}
};