str
MALparser(Client c)
{
InstrPtr p;
MalBlkRecord oldstate;
c->curprg->def->errors = 0;
oldstate = *c->curprg->def;
prepareMalBlk(c->curprg->def, CURRENT(c));
if (parseMAL(c, c->curprg, 0) || c->curprg->def->errors) {
/* just complete it for visibility */
pushEndInstruction(c->curprg->def);
/* caught errors */
showErrors(c);
if (c->listing)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
MSresetVariables(c, c->curprg->def, c->glb, oldstate.vtop);
resetMalBlk(c->curprg->def, 1);
/* now the parsing is done we should advance the stream */
c->fdin->pos += c->yycur;
c->yycur = 0;
throw(SYNTAX, "mal.parser", SYNTAX_GENERAL MANUAL_HELP);
}
/* now the parsing is done we should advance the stream */
c->fdin->pos += c->yycur;
c->yycur = 0;
/* check for unfinished blocks */
if (c->blkmode)
return MAL_SUCCEED;
/* empty files should be skipped as well */
if (c->curprg->def->stop == 1)
return MAL_SUCCEED;
p = getInstrPtr(c->curprg->def, 0);
if (p->token != FUNCTIONsymbol) {
if (c->listing)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
MSresetVariables(c, c->curprg->def, c->glb, oldstate.vtop);
resetMalBlk(c->curprg->def, 1);
throw(SYNTAX, "mal.parser", SYNTAX_SIGNATURE);
}
pushEndInstruction(c->curprg->def);
chkProgram(c->fdout, c->nspace, c->curprg->def);
if (c->curprg->def->errors) {
showErrors(c);
if (c->listing)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
MSresetVariables(c, c->curprg->def, c->glb, oldstate.vtop);
resetMalBlk(c->curprg->def, 1);
throw(MAL, "MAL.parser", SEMANTIC_GENERAL);
}
return MAL_SUCCEED;
}
void
addQueryToCache(Client c)
{
MalBlkPtr mb;
backend *be;
str msg = 0, pipe;
be = (backend *) c->sqlcontext;
assert(be && be->mvc); /* SQL clients should always have their state set */
pipe = getSQLoptimizer(be->mvc);
insertSymbol(c->nspace, c->curprg);
trimMalBlk(c->curprg->def);
c->blkmode = 0;
mb = c->curprg->def;
chkProgram(c->fdout, c->nspace, mb);
#ifdef _SQL_OPTIMIZER_DEBUG
mnstr_printf(GDKout, "ADD QUERY TO CACHE\n");
printFunction(GDKout, mb, 0, LIST_MAL_ALL);
#endif
/*
* An error in the compilation should be reported to the user.
* And if the debugging option is set, the debugger is called
* to allow inspection.
*/
if (mb->errors) {
showErrors(c);
if (c->listing)
printFunction(c->fdout, mb, 0, c->listing);
if (be->mvc->debug) {
msg = runMALDebugger(c, c->curprg);
if (msg != MAL_SUCCEED)
GDKfree(msg); /* ignore error */
}
return;
}
addOptimizers(c, mb, pipe);
msg = optimizeMALBlock(c, mb);
if (msg != MAL_SUCCEED) {
showScriptException(c->fdout, mb, 0, MAL, "%s", msg);
GDKfree(msg);
return;
}
/* time to execute the optimizers */
if (c->debug)
optimizerCheck(c, mb, "sql.baseline", -1, 0);
#ifdef _SQL_OPTIMIZER_DEBUG
mnstr_printf(GDKout, "ADD optimized QUERY TO CACHE\n");
printFunction(GDKout, mb, 0, LIST_MAL_ALL);
#endif
}
void partitionUniqueCalc(int * result, int ind, int left)
{
int val = 0;
int i;
int cond = 0;
if(left == 0)
{
printf("= ");
printFunction(result, ind);
}
for(val = 1; val <= left; val++)
{
result[ind] = val;
for(i = 0; i < ind; i++)
{
if(result[i] == result[ind])
{
cond = 1;
}
}
if(cond == 0)
{
partitionUniqueCalc(result, ind + 1, left - val);
}
cond = 0;
}
}
str
QOTshowPlan(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
str modnme;
str fcnnme;
Symbol s = NULL;
if (stk != 0) {
modnme = *getArgReference_str(stk, p, 1);
fcnnme = *getArgReference_str(stk, p, 2);
} else {
modnme = getArgDefault(mb, p, 1);
fcnnme = getArgDefault(mb, p, 2);
}
mnstr_printf(cntxt->fdout,"#showPlan()\n");
removeInstruction(mb, p);
if( modnme ) {
s = findSymbol(cntxt->nspace, putName(modnme, strlen(modnme)), putName(fcnnme, strlen(fcnnme)));
if (s == NULL) {
char buf[1024];
snprintf(buf,1024, "%s.%s", modnme, fcnnme);
throw(MAL, "optimizer.showPlan", RUNTIME_OBJECT_UNDEFINED ":%s", buf);
}
mb= s->def;
}
printFunction(cntxt->fdout, mb, 0, LIST_INPUT);
return MAL_SUCCEED;
}
void printScript(struct SCRIPT * script){
int i;
printf("\\** Script: %s *************************************/\n",script->name);
printf("[+] Global variables:\n");
if(script->nbvar){
for(i=0;i<script->nbvar;i++)
printf(" | -%s\n",script->variables[i]);
printf("\n");
}//if global variable
printManagers(&script->managers);
printf("\n");
printf("[+] Code:\n | -%d lines of code\n",script->nblines);
printf("[+] Script Functions:\n");
for(i=0;i<script->nbfunc;i++){
printf("------------------------\n");
printFunction(&script->functionslist[i]);
}
printf("------------------------\n");
printf("\n");
printf("[+] Script Procedures:\n");
for(i=0;i<script->nbproc;i++){
printf("------------------------\n");
printProcedure(&script->procedureslist[i]);
}
printf("------------------------\n");
printf("\n");
if(script->strciphered){
printf("[+] String ciphered by %s\n\n",
script->functionslist[script->cipherfunction].name);
}
printf("\\** End Script: %s *********************************/\n\n\n",script->name);
}
str
MDBlistMapi(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
(void) p;
(void) stk;
printFunction(cntxt->fdout, mb, 0, LIST_MAL_ALL);
return MAL_SUCCEED;
}
//printing all variables
count_dict printTable(string chrom, string start, string ref,
int A, int C, int T, int G,
int a, int c, int t, int g,
int insertion, int deletion, int refCount, int refCountrev)
{
string strand ;
int mispos = atoi(start.c_str());
int end = mispos + 1;
int cov;
string realRef;
int referenceCount;
int print = 0;
count_dict counts;
transform(ref.begin(), ref.end(), ref.begin(), ::toupper);
// clean up forward/reverse strand data
if (A + C + T + G + refCount > 0)
{
strand = "+";
realRef = ref;
referenceCount = refCount;
counts["A"] = A;
counts["C"] = C;
counts["G"] = G;
counts["T"] = T;
counts[realRef] = referenceCount;
cov = counts["A"] + counts["C"] + counts["G"] + counts["T"];
printFunction(counts, chrom, mispos, end,
realRef, cov, strand, insertion, deletion);
}
if (a + c + t + g + refCountrev > 0)
{
strand = "-";
realRef = reverse_complement(ref);
referenceCount = refCountrev;
counts["A"] = a;
counts["C"] = c;
counts["G"] = g;
counts["T"] = t;
counts[realRef] = referenceCount;
cov = counts["A"] + counts["C"] + counts["G"] + counts["T"];
printFunction(counts, chrom, mispos, end,
realRef, cov, strand, insertion, deletion);
}
return counts;
}
str
optimizeQuery(Client c)
{
MalBlkPtr mb;
backend *be;
str msg = 0, pipe;
be = (backend *) c->sqlcontext;
assert(be && be->mvc); /* SQL clients should always have their state set */
pipe = getSQLoptimizer(be->mvc);
trimMalBlk(c->curprg->def);
c->blkmode = 0;
mb = c->curprg->def;
chkProgram(c->fdout, c->nspace, mb);
#ifdef _SQL_OPTIMIZER_DEBUG
mnstr_printf(GDKout, "Optimize query\n");
printFunction(GDKout, mb, 0, LIST_MAL_ALL);
#endif
/*
* An error in the compilation should be reported to the user.
* And if the debugging option is set, the debugger is called
* to allow inspection.
*/
if (mb->errors) {
showErrors(c);
if (c->listing)
printFunction(c->fdout, mb, 0, c->listing);
return NULL;
}
addOptimizers(c, mb, pipe);
msg = optimizeMALBlock(c, mb);
if (msg)
return msg;
/* time to execute the optimizers */
if (c->debug)
optimizerCheck(c, mb, "sql.baseline", -1, 0);
#ifdef _SQL_OPTIMIZER_DEBUG
mnstr_printf(GDKout, "End Optimize Query\n");
printFunction(GDKout, mb, 0, LIST_MAL_ALL);
#endif
return NULL;
}
void printFunctions() {
fprintf(stderr, "Available functions:\n");
ClientFunctionRegistryEntry iter;
for (iter = clientFunctionRegisty; iter != NULL; iter = iter->hh.next) {
fprintf(stderr, "* ");
printFunction(iter);
fprintf(stderr, "\n");
}
}
/*
* The default SQL optimizer performs a limited set of operations
* that are known to be (reasonably) stable and effective.
* Finegrained control over the optimizer steps is available thru
* setting the corresponding SQL variable.
*
* This version simply runs through the MAL script and re-orders the instructions
* into catalog operations, query graph, and result preparation.
* This distinction is used to turn the function into a factory, which would
* enable re-entry when used as a cache-optimized query.
* The second optimization is move access mode changes on the base tables
* to the front of the plan.
*
*
*/
str
SQLoptimizer(Client c)
{
(void) c;
#ifdef _SQL_OPTIMIZER_DEBUG
mnstr_printf(GDKout, "SQLoptimizer\n");
printFunction(c->fdout, c->curprg->def, 0, LIST_MAL_DEBUG);
mnstr_printf(GDKout, "done\n");
#endif
return MAL_SUCCEED;
}
str OPTsql_append(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p){
str modnme;
str fcnnme;
str msg= MAL_SUCCEED;
Symbol s= NULL;
lng t,clk= GDKusec();
int actions = 0;
if( p )
removeInstruction(mb, p);
OPTDEBUGsql_append mnstr_printf(cntxt->fdout,"=APPLY OPTIMIZER sql_append\n");
if( p && p->argc > 1 ){
if( getArgType(mb,p,1) != TYPE_str ||
getArgType(mb,p,2) != TYPE_str ||
!isVarConstant(mb,getArg(p,1)) ||
!isVarConstant(mb,getArg(p,2))
) {
throw(MAL, "optimizer.sql_append", ILLARG_CONSTANTS);
}
if( stk != 0){
modnme= *getArgReference_str(stk,p,1);
fcnnme= *getArgReference_str(stk,p,2);
} else {
modnme= getArgDefault(mb,p,1);
fcnnme= getArgDefault(mb,p,2);
}
s= findSymbol(cntxt->nspace, putName(modnme,strlen(modnme)),putName(fcnnme,strlen(fcnnme)));
if( s == NULL) {
char buf[1024];
snprintf(buf,1024, "%s.%s",modnme,fcnnme);
throw(MAL, "optimizer.sql_append", RUNTIME_OBJECT_UNDEFINED ":%s", buf);
}
mb = s->def;
stk= 0;
}
if( mb->errors ){
/* when we have errors, we still want to see them */
addtoMalBlkHistory(mb,"sql_append");
return MAL_SUCCEED;
}
actions= OPTsql_appendImplementation(cntxt, mb,stk,p);
msg= optimizerCheck(cntxt, mb, "optimizer.sql_append", actions, t=(GDKusec() - clk));
OPTDEBUGsql_append {
mnstr_printf(cntxt->fdout,"=FINISHED sql_append %d\n",actions);
printFunction(cntxt->fdout,mb,0,LIST_MAL_ALL );
}
DEBUGoptimizers
mnstr_printf(cntxt->fdout,"#opt_reduce: " LLFMT " ms\n",t);
QOTupdateStatistics("sql_append",actions,t);
addtoMalBlkHistory(mb,"sql_append");
return msg;
}
str
MDBlist3(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p)
{
str modnme = *getArgReference_str(stk, p, 1);
str fcnnme = *getArgReference_str(stk, p, 2);
Symbol s = NULL;
s = findSymbol(cntxt->nspace, putName(modnme), putName(fcnnme));
if (s == NULL)
throw(MAL,"mdb.list","Could not find %s.%s", modnme, fcnnme);
printFunction(cntxt->fdout, s->def, 0, LIST_MAL_NAME );
(void) mb; /* fool compiler */
return MAL_SUCCEED;
}
void printLinkedList(linkedList l, void (*printFunction)(void*)){
if(l) {
printf("Printing linked list\n");
linkedNode current = l->head;
while(current){
printFunction(current->content);
current = current->next;
}
}
printf("\n");
}
int commandsPrimary(char* command){
if (strcmp(command, "print") == 0){
printFunction();
return 1;
}
else if (strcmp(command, "quit") == 0){
quitFunction();
return -1;
}
else{
printf("Not a valid command!\n");
return 0;
}
}
void partitionAllCalc(int * result, int ind, int left)
{
int val = 0;
if(left == 0)
{
printf("= ");
printFunction(result, ind);
}
for(val = 1; val <= left; val++)
{
result[ind] = val;
partitionAllCalc(result, ind + 1, left - val);
}
}
void AstPrinter::printScopeDeclarations(Scope* scope) {
Scope::VarIterator varIterator(scope);
while(varIterator.hasNext()) {
AstVar *var = varIterator.next();
print(typeToName(var->type()));
print(" ");
print(var->name());
print(";\n");
}
Scope::FunctionIterator funcIterator(scope);
while(funcIterator.hasNext()) {
AstFunction *func = funcIterator.next();
printFunction(func);
}
print("\n");
}
str
SQLoptimizeQuery(Client c, MalBlkPtr mb)
{
backend *be;
str msg = 0;
str pipe;
if (mb->stop > 0 &&
mb->stmt[mb->stop-1]->token == REMsymbol &&
mb->stmt[mb->stop-1]->argc > 0 &&
mb->var[mb->stmt[mb->stop-1]->argv[0]].value.vtype == TYPE_str &&
mb->var[mb->stmt[mb->stop-1]->argv[0]].value.val.sval &&
strncmp(mb->var[mb->stmt[mb->stop-1]->argv[0]].value.val.sval, "total", 5) == 0)
return MAL_SUCCEED; /* already optimized */
be = (backend *) c->sqlcontext;
assert(be && be->mvc); /* SQL clients should always have their state set */
c->blkmode = 0;
chkProgram(c->usermodule, mb);
/*
* An error in the compilation should be reported to the user.
* And if the debugging option is set, the debugger is called
* to allow inspection.
*/
if (mb->errors) {
if (c->listing)
printFunction(c->fdout, mb, 0, c->listing);
if (be->mvc->debug) {
msg = runMALDebugger(c, c->curprg->def);
if (msg != MAL_SUCCEED)
freeException(msg); /* ignore error */
}
return NULL;
}
pipe = getSQLoptimizer(be->mvc);
msg = addOptimizers(c, mb, pipe, FALSE);
if (msg)
return msg;
mb->keephistory |= be->mvc->emod & mod_debug;
msg = optimizeMALBlock(c, mb);
return msg;
}
int main()
{
FILE*file=fopen("input.txt","r");
if(!file)
{
printf("can't open file\n");
return 1;
}
GF2n m, a, b, Px, Py, n, Qx, Qy;
FUNCTION ff;
GFread(file,m,ff,a,b,Px,Py,n,Qx,Qy);
printValue(m,"m");printValue(a,"a");
printValue(b,"b");printValue(Px,"Px");printValue(Py,"Py");
printValue(n,"n");printValue(Qx,"Qx");printValue(Qy,"Qy");
printFunction(ff);
return 0;
}
void numberToFunction(int number, char* secondary){
if (number == 1){
readFunction(secondary);
}
else if (number == 2){
writeFunction(secondary);
}
else if (number == 3){
deleteFunction(secondary);
}
else if (number == 4){
printFunction();
}
else if (number == 0){
printf("Not a valid command!\n");
}
else if (number == 404){
printf("The file you provided does not exist.\n");
}
}
void printht(){
printFunction();
// hashmapProcess(functionmap,&printFunction);
/*
outer_hash_entry* entry = hashmapGet(functionmap, "main");
inner_hash_entry* inVal;
int error;
//inVal = malloc(sizeof(inner_hash_entry));
int i;
dr_fprintf(logOut, "fl=%s\nfn=%s\n",entry->file, entry->function_name);
for(i = 0; i < size_arr; i++){
printf("Looking for addr %d\n", addr_arr[i]);
error = hashmap_get(entry->mapAddrs, addr_arr[i], (void**)(&inVal));
if(error == MAP_OK){
printf("%d %d %d bits %d\n", inVal->addr, inVal->call_count, inVal->line_number, inVal->no_bits );
dr_fprintf(logOut, ""PIFX" %d %d\n",inVal->addr,inVal->line_number,inVal->call_count);
}
else
printf("not this function %d\n", error);
}
*/
/*
entry = hashmapGet(functionmap, "substr");
dr_fprintf(logOut, "fl=%s\nfn=%s\n",entry->file, entry->function_name);
for(i = 0; i < size_arr; i++){
printf("Looking for addr %d\n", addr_arr[i]);
error = hashmap_get(entry->mapAddrs, addr_arr[i], (void**)(&inVal));
if(error == MAP_OK){
printf("%d %d %d\n", inVal->addr, inVal->call_count, inVal->line_number );
dr_fprintf(logOut, ""PIFX" %d %d\n",inVal->addr,inVal->line_number,inVal->call_count);
}
else
printf("not this function %d\n", error);
}
*/
}
void partitionIncreasingCalc(int * result, int ind, int left)
{
int val = 0;
if(left == 0)
{
printf("= ");
printFunction(result, ind);
}
for(val = 1; val <= left; val++)
{
result[ind] = val;
if(ind == 0)
{
partitionIncreasingCalc(result, ind + 1, left - val);
}
else if(result[ind] > result[ind -1])
{
partitionIncreasingCalc(result, ind + 1, left - val);
}
}
}
str
SQLengineIntern(Client c, backend *be)
{
str msg = MAL_SUCCEED;
MalStkPtr oldglb = c->glb;
char oldlang = be->language;
mvc *m = be->mvc;
InstrPtr p;
MalBlkPtr mb;
if (oldlang == 'X') { /* return directly from X-commands */
sqlcleanup(be->mvc, 0);
return MAL_SUCCEED;
}
if (m->emod & mod_explain) {
if (be->q && be->q->code)
printFunction(c->fdout, ((Symbol) (be->q->code))->def, 0, LIST_MAL_NAME | LIST_MAL_VALUE | LIST_MAL_MAPI);
else if (be->q)
msg = createException(PARSE, "SQLparser", "%s", (*m->errstr) ? m->errstr : "39000!program contains errors");
else if (c->curprg->def)
printFunction(c->fdout, c->curprg->def, 0, LIST_MAL_NAME | LIST_MAL_VALUE | LIST_MAL_MAPI);
goto cleanup_engine;
}
if (m->emod & mod_dot) {
if (be->q && be->q->code)
showFlowGraph(((Symbol) (be->q->code))->def, 0, "stdout-mapi");
else if (be->q)
msg = createException(PARSE, "SQLparser", "%s", (*m->errstr) ? m->errstr : "39000!program contains errors");
else if (c->curprg->def)
showFlowGraph(c->curprg->def, 0, "stdout-mapi");
goto cleanup_engine;
}
#ifdef SQL_SCENARIO_DEBUG
mnstr_printf(GDKout, "#Ready to execute SQL statement\n");
#endif
if (c->curprg->def->stop == 1) {
sqlcleanup(be->mvc, 0);
return MAL_SUCCEED;
}
if (m->emode == m_inplace) {
msg = SQLexecutePrepared(c, be, be->q);
goto cleanup_engine;
}
if (m->emode == m_prepare)
goto cleanup_engine;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = 0;
be->language = 'D';
/*
* The code below is copied from MALengine, which handles execution
* in the context of a user global environment. We have a private
* environment.
*/
if (MALcommentsOnly(c->curprg->def)) {
msg = MAL_SUCCEED;
} else {
msg = (str) runMAL(c, c->curprg->def, 0, 0);
}
cleanup_engine:
if (m->type == Q_SCHEMA)
qc_clean(m->qc);
if (msg) {
enum malexception type = getExceptionType(msg);
if (type == OPTIMIZER) {
MSresetInstructions(c->curprg->def, 1);
freeVariables(c, c->curprg->def, NULL, be->vtop);
be->language = oldlang;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
if ( msg)
GDKfree(msg);
return SQLrecompile(c, be); // retry compilation
} else {
/* don't print exception decoration, just the message */
char *n = NULL;
char *o = msg;
while ((n = strchr(o, '\n')) != NULL) {
*n = '\0';
mnstr_printf(c->fdout, "!%s\n", getExceptionMessage(o));
*n++ = '\n';
o = n;
}
if (*o != 0)
mnstr_printf(c->fdout, "!%s\n", getExceptionMessage(o));
}
showErrors(c);
m->session->status = -10;
}
mb = c->curprg->def;
if (m->type != Q_SCHEMA && be->q && msg) {
qc_delete(m->qc, be->q);
} else if (m->type != Q_SCHEMA && be->q && mb && varGetProp(mb, getArg(p = getInstrPtr(mb, 0), 0), runonceProp)) {
msg = SQLCacheRemove(c, getFunctionId(p));
qc_delete(be->mvc->qc, be->q);
///* this should invalidate any match */
//be->q->key= -1;
//be->q->paramlen = -1;
///* qc_delete(be->q) */
}
be->q = NULL;
sqlcleanup(be->mvc, (!msg) ? 0 : -1);
MSresetInstructions(c->curprg->def, 1);
freeVariables(c, c->curprg->def, NULL, be->vtop);
be->language = oldlang;
/*
* Any error encountered during execution should block further processing
* unless auto_commit has been set.
*/
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
return msg;
}
/**
* Application entry point.
*/
int main( int argc, char **argv )
{
pthread_t *threads = NULL;
int numPorts = -1;
struct ThreadOutData **outData = NULL;
struct hostent *hostInfo = NULL;
int counter = 0;
int currentPort = -1;
int i = 0;
AppConfig appConfig;
programName = argv[0];
AppConfig_init( &appConfig );
AppConfig_parseCommandLine( &appConfig, argc, argv );
threads = (pthread_t *)calloc( appConfig.numThreads, sizeof( pthread_t ) );
numPorts = appConfig.toPort - appConfig.fromPort;
outData = malloc( sizeof( struct ThreadOutData ) * numPorts );
Timer_start();
hostInfo = resolveHostInfo( appConfig.hostName );
if( hostInfo == NULL )
{
fprintf( stderr, "Unable to resolve host: %s\n", appConfig.hostName );
return EXIT_FAILURE;
}
printf( "Scanning open ports on %s (%s)\n", inet_ntoa( *((struct in_addr *)hostInfo->h_addr_list[0] ) ), appConfig.hostName );
currentPort = appConfig.fromPort;
while( currentPort < appConfig.toPort )
{
int threadsCreated = 0;
unsigned int i = 0;
for( i = 0; i < appConfig.numThreads; i++ )
{
if( currentPort <= appConfig.toPort )
{
struct ThreadInData *inData = (struct ThreadInData*)malloc( sizeof( struct ThreadInData ) );
memset( inData, 0, sizeof( struct ThreadInData ) );
inData->hostInfo = hostInfo;
inData->port = currentPort;
pthread_create( &threads[ i ], NULL, threadRun, (void *)inData );
currentPort++;
threadsCreated++;
}
}
for( i = 0; i < threadsCreated; i++ )
{
pthread_join( threads[ i ], (void **)&outData[ counter ] );
counter++;
}
}
for( i = 0; i < numPorts; i++ )
{
void ( *printFunction )( struct ThreadOutData * ) = printOpenClosed;
if( FORMAT_PLUSES_MINUSES == appConfig.printFormat )
{
printFunction = printPlusesMinuses;
}
if( outData[ i ]->isOpen || appConfig.showOnlyOpen == 0 )
{
printFunction( outData[ i ] );
}
free( outData[ i ]->serviceName );
}
Timer_stop();
printf( "Elapsed time: %ld seconds\n", Timer_getElapsedTime() );
if( threads != NULL )
free( threads );
return EXIT_SUCCESS;
}
/*
* The generic solution to the multiplex operators is to translate
* them to a MAL loop.
* The call optimizer.multiplex(MOD,FCN,A1,...An) introduces the following code
* structure:
*
* @verbatim
* A1rev:=bat.reverse(A1);
* resB:= bat.new(A1);
* barrier (h,t):= iterator.new(A1);
* $1:= algebra.fetch(A1,h);
* $2:= A2; # in case of constant?
* ...
* cr:= MOD.FCN($1,...,$n);
* y:=algebra.fetch(A1rev,h);
* bat.insert(resB,y,cr);
* redo (h,t):= iterator.next(A1);
* end h;
* @end verbatim
*
* The algorithm consists of two phases: phase one deals with
* collecting the relevant information, phase two is the actual
* code construction.
*/
static str
OPTexpandMultiplex(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i = 2, resB, iter = 0, cr;
int hvar, tvar;
int x, y;
str mod, fcn;
int *alias;
InstrPtr q;
int ht, tt;
(void) cntxt;
(void) stk;
ht = getHeadType(getArgType(mb, pci, 0));
if (ht != TYPE_oid)
throw(MAL, "optimizer.multiplex", "Target head type is missing");
tt = getTailType(getArgType(mb, pci, 0));
if (tt== TYPE_any)
throw(MAL, "optimizer.multiplex", "Target tail type is missing");
if (isAnyExpression(getArgType(mb, pci, 0)))
throw(MAL, "optimizer.multiplex", "Target type is missing");
mod = VALget(&getVar(mb, getArg(pci, 1))->value);
mod = putName(mod,strlen(mod));
fcn = VALget(&getVar(mb, getArg(pci, 2))->value);
fcn = putName(fcn,strlen(fcn));
/* search the iterator bat */
for (i = 3; i < pci->argc; i++)
if (isaBatType(getArgType(mb, pci, i))) {
iter = getArg(pci, i);
if (getHeadType(getVarType(mb,iter)) != TYPE_oid)
throw(MAL, "optimizer.multiplex", "Iterator BAT is not OID-headed");
break;
}
if( i == pci->argc)
throw(MAL, "optimizer.multiplex", "Iterator BAT type is missing");
OPTDEBUGmultiplex {
mnstr_printf(cntxt->fdout,"#calling the optimize multiplex script routine\n");
printFunction(cntxt->fdout,mb, 0, LIST_MAL_ALL );
mnstr_printf(cntxt->fdout,"#multiplex against operator %d %s\n",iter, getTypeName(getVarType(mb,iter)));
printInstruction(cntxt->fdout,mb, 0, pci,LIST_MAL_ALL);
}
/*
* Beware, the operator constant (arg=1) is passed along as well,
* because in the end we issue a recursive function call that should
* find the actual arguments at the proper place of the callee.
*/
alias= (int*) GDKmalloc(sizeof(int) * pci->maxarg);
if (alias == NULL)
return NULL;
/* x := bat.reverse(A1); */
x = newTmpVariable(mb, newBatType(getTailType(getVarType(mb,iter)),
getHeadType(getVarType(mb,iter))));
q = newFcnCall(mb, batRef, reverseRef);
getArg(q, 0) = x;
q = pushArgument(mb, q, iter);
/* resB := new(refBat) */
q = newFcnCall(mb, batRef, newRef);
resB = getArg(q, 0);
setVarType(mb, getArg(q, 0), newBatType(ht, tt));
q = pushType(mb, q, ht);
q = pushType(mb, q, tt);
/* barrier (h,r) := iterator.new(refBat); */
q = newFcnCall(mb, iteratorRef, newRef);
q->barrier = BARRIERsymbol;
hvar = newTmpVariable(mb, TYPE_any);
getArg(q,0) = hvar;
tvar = newTmpVariable(mb, TYPE_any);
q= pushReturn(mb, q, tvar);
(void) pushArgument(mb,q,iter);
/* $1:= algebra.fetch(Ai,h) or constant */
alias[i] = tvar;
for (i++; i < pci->argc; i++)
if (isaBatType(getArgType(mb, pci, i))) {
q = newFcnCall(mb, algebraRef, "fetch");
alias[i] = newTmpVariable(mb, getTailType(getArgType(mb, pci, i)));
getArg(q, 0) = alias[i];
q= pushArgument(mb, q, getArg(pci, i));
(void) pushArgument(mb, q, hvar);
}
/* cr:= mod.CMD($1,...,$n); */
q = newFcnCall(mb, mod, fcn);
cr = getArg(q, 0) = newTmpVariable(mb, TYPE_any);
for (i = 3; i < pci->argc; i++)
if (isaBatType(getArgType(mb, pci, i))) {
q= pushArgument(mb, q, alias[i]);
} else {
q = pushArgument(mb, q, getArg(pci, i));
}
/* y := algebra.fetch(x,h); */
y = newTmpVariable(mb, getHeadType(getVarType(mb,iter)));
q = newFcnCall(mb, algebraRef, "fetch");
getArg(q, 0) = y;
q = pushArgument(mb, q, x);
q = pushArgument(mb, q, hvar);
/* insert(resB,h,cr);
not append(resB, cr); the head type (oid) may dynamically change */
q = newFcnCall(mb, batRef, insertRef);
q= pushArgument(mb, q, resB);
q= pushArgument(mb, q, y);
(void) pushArgument(mb, q, cr);
/* redo (h,r):= iterator.next(refBat); */
q = newFcnCall(mb, iteratorRef, nextRef);
q->barrier = REDOsymbol;
getArg(q,0) = hvar;
q= pushReturn(mb, q, tvar);
(void) pushArgument(mb,q,iter);
q = newAssignment(mb);
q->barrier = EXITsymbol;
getArg(q,0) = hvar;
(void) pushReturn(mb, q, tvar);
q = newAssignment(mb);
getArg(q, 0) = getArg(pci, 0);
(void) pushArgument(mb, q, resB);
GDKfree(alias);
return MAL_SUCCEED;
}
void ShortestPathAnalysis::dump() {
printFunction(llvm::errs());
}
int main(int argc, char** argv)
{
if (!(argc == 3)) {
printf("Usage: newton <poly1|sin|xsin|poly2|imaginary> <initial guess>\n");
wrong();
}
int valid = 0; //Check if the argument is valid or not
if (strcmp(argv[1], "poly1") == 0) //Compare the argument
valid = 1;
else if (strcmp(argv[1], "sin") == 0) //Compare the argument
valid = 1;
else if (strcmp(argv[1], "xsin") == 0) //Compare the argument
valid = 1;
else if (strcmp(argv[1], "poly2") == 0) //Compare the argument
valid = 1;
else if (strcmp(argv[1], "imaginary") == 0) //Compare the argument
valid = 1;
else
valid = 0; //Sets the check variable to 0 if it's not equal to any of the strings mentioned above
if (valid == 0) {
printf("Error: %s is not a valid function name\n", argv[1]); //Prints out this error if the entered argument is invalid
exit(1);
}
printFunction(argv[1]);
double start = atof(argv[2]);
int i = 0;
double y = f(argv[1], start);
double yPrime = fPrime(argv[1], start);
double yIteration12 = y;
double startIteration12 = start;
//Following snippet based on the algorithm provided on the handout which goes like -
/*x = starting point
y = f(x)
dy = f'(x)
iterations = 0;
while (abs(y) > TOLERANCE and iterations < MAX_ITERATIONS)
x = x - f(x)/f'(x)
y = f(x)
iterations++
}*/
while (fabs(y) > TOLERANCE && i <= MAX_ITER) {
printf("At iteration %d, x=%f, y=%f, y'=%f\n", i, start, y, yPrime);
if (yPrime == 0.000000) {
printf("Error: at x=%f, f'(x)=%d\n", start, (int) yPrime);
wrong();
}
startIteration12 = start;
start = start - y/yPrime;
yIteration12 = y;
y = f(argv[1], start);
yPrime = fPrime(argv[1], start);
i++;
}
//END OF SNIPPET
if (!(y < 0.000001 && y > -0.000001))
printf("Error: after 12 iterations, x=%f and f(x)=%f\n", startIteration12, yIteration12);
else {
printf("At iteration %d, x=%f, y=%f, and y'=%f\n", i, start, y, yPrime);
printf("Solution: iteration=%d x=%f y=%f\n", i, start, y);
}
return 0;
}
str
MALengine(Client c)
{
Symbol prg;
str msg = MAL_SUCCEED;
MalBlkRecord oldstate = *c->curprg->def;
oldstate.stop = 0;
if (c->blkmode)
return MAL_SUCCEED;
prg = c->curprg;
if (prg == NULL)
throw(SYNTAX, "mal.engine", SYNTAX_SIGNATURE);
if (prg->def == NULL)
throw(SYNTAX, "mal.engine", SYNTAX_SIGNATURE);
if (prg->def->errors > 0) {
showErrors(c);
if (c->listing)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
MSresetVariables(c, c->curprg->def, c->glb, oldstate.vtop);
resetMalBlk(c->curprg->def, 1);
throw(MAL, "mal.engine", PROGRAM_GENERAL);
}
if (prg->def->stop == 1 || MALcommentsOnly(prg->def))
return 0; /* empty block */
if (c->glb) {
if (prg->def && c->glb->stksize < prg->def->vsize){
c->glb = reallocGlobalStack(c->glb, prg->def->vsize);
if( c->glb == NULL)
throw(MAL, "mal.engine", MAL_MALLOC_FAIL);
}
c->glb->stktop = prg->def->vtop;
c->glb->blk = prg->def;
c->glb->cmd = (c->itrace && c->itrace != 'C') ? 'n' : 0;
}
if (c->listing > 1)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
/*
* In interactive mode we should avoid early garbage collection of values.
* This can be controlled by the clean up control at the instruction level
* and marking all non-temporary variables as being (potentially) used.
*/
if (c->glb) {
c->glb->pcup = 0;
c->glb->keepAlive = TRUE; /* no garbage collection */
}
if (prg->def->errors == 0)
msg = (str) runMAL(c, prg->def, 0, c->glb);
if (msg) {
/* ignore "internal" exceptions */
str fcn = getExceptionPlace(msg); /* retrieves from "first" exception */
if (strcmp(fcn, "client.quit") != 0)
dumpExceptionsToStream(c->fdout, msg);
GDKfree(fcn);
if (!c->listing)
printFunction(c->fdout, c->curprg->def, 0, c->listing);
showErrors(c);
}
MSresetVariables(c, prg->def, c->glb, 0);
resetMalBlk(prg->def, 1);
if (c->glb) {
/* for global stacks avoid reinitialization from this point */
c->glb->stkbot = prg->def->vtop;
}
prg->def->errors = 0;
if (c->itrace)
mnstr_printf(c->fdout, "mdb>#EOD\n");
return msg;
}
int
OPTrecyclerImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int i, j, cnt, cand, actions = 1, marks = 0;
InstrPtr *old, q,p;
int limit;
char *recycled;
(void) cntxt;
(void) stk;
(void) pci;
limit = mb->stop;
old = mb->stmt;
/* watch out, newly created instructions may introduce new variables */
recycled = GDKzalloc(sizeof(char) * mb->vtop * 2);
if (recycled == NULL)
return 0;
if (newMalBlkStmt(mb, mb->ssize) < 0) {
GDKfree(recycled);
return 0;
}
pushInstruction(mb, old[0]);
for (i = 1; i < limit; i++) {
p = old[i];
if (p->token == ENDsymbol )
break;
/* the first non-dataflow barrier breaks the recycler code*/
if (blockStart(p) && !(getFunctionId(p) && getFunctionId(p) == dataflowRef) )
break;
if ( isUpdateInstruction(p) || hasSideEffects(p,TRUE)){
/* update instructions are not recycled but monitored*/
pushInstruction(mb, p);
if (isUpdateInstruction(p)) {
if (getModuleId(p) == batRef && isaBatType(getArgType(mb, p, 1))) {
q = newFcnCall(mb, "recycle", "reset");
pushArgument(mb, q, getArg(p, 1));
actions++;
}
if (getModuleId(p) == sqlRef) {
q= copyInstruction(p);
getModuleId(q) = recycleRef;
actions++;
}
}
continue;
}
// Not all instruction may be recycled. In particular, we should avoid
// MAL function with implicit/recursive side effects.
// This can not always be detected easily. Likewise, we ignore cheap operations
// Therefore, we use a safe subset to start with
if ( ! (getModuleId(p) == sqlRef || getModuleId(p)== batRef ||
getModuleId(p) == algebraRef || getModuleId(p)==batcalcRef ||
getModuleId(p)== aggrRef || getModuleId(p)== groupRef ||
getModuleId(p)== batstrRef || getModuleId(p)== batmmathRef ||
getModuleId(p)== arrayRef || getModuleId(p)== batmtimeRef ||
getModuleId(p)== batcalcRef || getModuleId(p)== pcreRef ||
getModuleId(p)== mtimeRef || getModuleId(p) == calcRef ||
getModuleId(p)== dateRef || getModuleId(p) == timestampRef ||
getModuleId(p)== matRef )
){
pushInstruction(mb,p);
continue;
}
/* general rule: all arguments should be constants or recycled*/
cnt = 0;
for (j = p->retc; j < p->argc; j++)
if (recycled[getArg(p, j)] || isVarConstant(mb, getArg(p, j)) || isFunctionArgument(mb,getArg(p,j)) )
cnt++;
cand = 0;
for (j =0; j< p->retc; j++)
if (recycled[getArg(p, j)] ==0)
cand++;
if (cnt == p->argc - p->retc && cand == p->retc) {
marks++;
p->recycle = RECYCLING; /* this instruction is to be monitored */
for (j = 0; j < p->retc; j++)
recycled[getArg(p, j)] = 1;
}
pushInstruction(mb, p);
}
for (; i < limit; i++)
pushInstruction(mb, old[i]);
GDKfree(old);
GDKfree(recycled);
mb->recycle = marks > 0;
OPTDEBUGrecycle {
mnstr_printf(cntxt->fdout, "#recycle optimizer: ");
printFunction(cntxt->fdout,mb, 0, LIST_MAL_ALL);
}
return actions + marks;
}
/*
* BEWARE: SQLstatementIntern only commits after all statements found
* in expr are executed, when autocommit mode is enabled.
*
* The tricky part for this statement is to ensure that the SQL statement
* is executed within the client context specified. This leads to context juggling.
*/
str
SQLstatementIntern(Client c, str *expr, str nme, int execute, bit output, res_table **result)
{
int status = 0;
int err = 0;
mvc *o, *m;
int ac, sizevars, topvars;
sql_var *vars;
int oldvtop, oldstop = 1;
buffer *b;
char *n;
stream *buf;
str msg = MAL_SUCCEED;
backend *be, *sql = (backend *) c->sqlcontext;
size_t len = strlen(*expr);
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#SQLstatement:%s\n", *expr);
#endif
if (!sql) {
msg = SQLinitEnvironment(c, NULL, NULL, NULL);
sql = (backend *) c->sqlcontext;
}
if (msg){
GDKfree(msg);
throw(SQL, "SQLstatement", "Catalogue not available");
}
initSQLreferences();
m = sql->mvc;
ac = m->session->auto_commit;
o = MNEW(mvc);
if (!o)
throw(SQL, "SQLstatement", "Out of memory");
*o = *m;
/* create private allocator */
m->sa = NULL;
SQLtrans(m);
status = m->session->status;
m->type = Q_PARSE;
be = sql;
sql = backend_create(m, c);
sql->output_format = be->output_format;
m->qc = NULL;
m->caching = 0;
m->user_id = m->role_id = USER_MONETDB;
if (result)
m->reply_size = -2; /* do not cleanup, result tables */
/* mimick a client channel on which the query text is received */
b = (buffer *) GDKmalloc(sizeof(buffer));
n = GDKmalloc(len + 1 + 1);
strncpy(n, *expr, len);
n[len] = '\n';
n[len + 1] = 0;
len++;
buffer_init(b, n, len);
buf = buffer_rastream(b, "sqlstatement");
scanner_init(&m->scanner, bstream_create(buf, b->len), NULL);
m->scanner.mode = LINE_N;
bstream_next(m->scanner.rs);
m->params = NULL;
m->argc = 0;
m->session->auto_commit = 0;
if (!m->sa)
m->sa = sa_create();
/*
* System has been prepared to parse it and generate code.
* Scan the complete string for SQL statements, stop at the first error.
*/
c->sqlcontext = sql;
while (msg == MAL_SUCCEED && m->scanner.rs->pos < m->scanner.rs->len) {
sql_rel *r;
stmt *s;
MalStkPtr oldglb = c->glb;
if (!m->sa)
m->sa = sa_create();
m->sym = NULL;
if ((err = sqlparse(m)) ||
/* Only forget old errors on transaction boundaries */
(mvc_status(m) && m->type != Q_TRANS) || !m->sym) {
if (!err)
err = mvc_status(m);
if (*m->errstr)
msg = createException(PARSE, "SQLparser", "%s", m->errstr);
*m->errstr = 0;
sqlcleanup(m, err);
execute = 0;
if (!err)
continue;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
/*
* We have dealt with the first parsing step and advanced the input reader
* to the next statement (if any).
* Now is the time to also perform the semantic analysis,
* optimize and produce code.
* We don't search the cache for a previous incarnation yet.
*/
MSinitClientPrg(c, "user", nme);
oldvtop = c->curprg->def->vtop;
oldstop = c->curprg->def->stop;
r = sql_symbol2relation(m, m->sym);
s = sql_relation2stmt(m, r);
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#SQLstatement:\n");
#endif
scanner_query_processed(&(m->scanner));
if (s == 0 || (err = mvc_status(m))) {
msg = createException(PARSE, "SQLparser", "%s", m->errstr);
handle_error(m, c->fdout, status);
sqlcleanup(m, err);
/* restore the state */
MSresetInstructions(c->curprg->def, oldstop);
freeVariables(c, c->curprg->def, c->glb, oldvtop);
c->curprg->def->errors = 0;
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
/* generate MAL code */
if (backend_callinline(sql, c, s, 1) == 0)
addQueryToCache(c);
else
err = 1;
if (err ||c->curprg->def->errors) {
/* restore the state */
MSresetInstructions(c->curprg->def, oldstop);
freeVariables(c, c->curprg->def, c->glb, oldvtop);
c->curprg->def->errors = 0;
msg = createException(SQL, "SQLparser", "Errors encountered in query");
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#result of sql.eval()\n");
printFunction(c->fdout, c->curprg->def, 0, c->listing);
#endif
if (execute) {
MalBlkPtr mb = c->curprg->def;
if (!output)
sql->out = NULL; /* no output */
msg = runMAL(c, mb, 0, 0);
MSresetInstructions(mb, oldstop);
freeVariables(c, mb, NULL, oldvtop);
}
sqlcleanup(m, 0);
if (!execute) {
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
goto endofcompile;
}
#ifdef _SQL_COMPILE
mnstr_printf(c->fdout, "#parse/execute result %d\n", err);
#endif
assert(c->glb == 0 || c->glb == oldglb); /* detect leak */
c->glb = oldglb;
}
if (m->results && result) { /* return all results sets */
*result = m->results;
m->results = NULL;
}
/*
* We are done; a MAL procedure resides in the cache.
*/
endofcompile:
if (execute)
MSresetInstructions(c->curprg->def, 1);
c->sqlcontext = be;
backend_destroy(sql);
GDKfree(n);
GDKfree(b);
bstream_destroy(m->scanner.rs);
if (m->sa)
sa_destroy(m->sa);
m->sa = NULL;
m->sym = NULL;
/* variable stack maybe resized, ie we need to keep the new stack */
status = m->session->status;
sizevars = m->sizevars;
topvars = m->topvars;
vars = m->vars;
*m = *o;
_DELETE(o);
m->sizevars = sizevars;
m->topvars = topvars;
m->vars = vars;
m->session->status = status;
m->session->auto_commit = ac;
return msg;
}
str OPTwrapper (Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr p){
str modnme = "(NONE)";
str fcnnme = 0;
str msg= MAL_SUCCEED;
Symbol s= NULL;
lng t,clk= GDKusec();
int i, actions = 0;
char optimizer[256];
InstrPtr q;
if( p == NULL)
throw(MAL, "opt_wrapper", "missing optimizer statement");
snprintf(optimizer,256,"%s", fcnnme = getFunctionId(p));
q= copyInstruction(p);
OPTIMIZERDEBUG
mnstr_printf(cntxt->fdout,"=APPLY OPTIMIZER %s\n",fcnnme);
if( p && p->argc > 1 ){
if( getArgType(mb,p,1) != TYPE_str ||
getArgType(mb,p,2) != TYPE_str ||
!isVarConstant(mb,getArg(p,1)) ||
!isVarConstant(mb,getArg(p,2))
) {
freeInstruction(q);
throw(MAL, optimizer, ILLARG_CONSTANTS);
}
if( stk != 0){
modnme= *getArgReference_str(stk,p,1);
fcnnme= *getArgReference_str(stk,p,2);
} else {
modnme= getArgDefault(mb,p,1);
fcnnme= getArgDefault(mb,p,2);
}
removeInstruction(mb, p);
s= findSymbol(cntxt->nspace, putName(modnme,strlen(modnme)),putName(fcnnme,strlen(fcnnme)));
if( s == NULL) {
freeInstruction(q);
throw(MAL, optimizer, RUNTIME_OBJECT_UNDEFINED ":%s.%s", modnme, fcnnme);
}
mb = s->def;
stk= 0;
} else if( p )
removeInstruction(mb, p);
if( mb->errors ){
/* when we have errors, we still want to see them */
addtoMalBlkHistory(mb,getModuleId(q));
freeInstruction(q);
return MAL_SUCCEED;
}
for ( i=0; codes[i].nme; i++)
if ( strcmp(codes[i].nme, optimizer)== 0 ){
actions = (int)(*(codes[i].fcn))(cntxt, mb, stk,0);
break;
}
if ( codes[i].nme == 0){
freeInstruction(q);
throw(MAL, optimizer, RUNTIME_OBJECT_UNDEFINED ":%s.%s", modnme, fcnnme);
}
msg= optimizerCheck(cntxt, mb, optimizer, actions, t=(GDKusec() - clk));
OPTIMIZERDEBUG {
mnstr_printf(cntxt->fdout,"=FINISHED %s %d\n",optimizer, actions);
printFunction(cntxt->fdout,mb,0,LIST_MAL_DEBUG );
}
DEBUGoptimizers
mnstr_printf(cntxt->fdout,"#optimizer %-11s %3d actions %5d MAL instructions ("SZFMT" K) " LLFMT" usec\n", optimizer, actions, mb->stop,
((sizeof( MalBlkRecord) +mb->ssize * offsetof(InstrRecord, argv)+ mb->vtop * sizeof(int) /* argv estimate */ +mb->vtop* sizeof(VarRecord) + mb->vsize*sizeof(VarPtr)+1023)/1024),
t);
QOTupdateStatistics(getModuleId(q),actions,t);
addtoMalBlkHistory(mb,getModuleId(q));
freeInstruction(q);
return msg;
}
