From ae5bf4d6e70060bbee5c40575a39dfd5f6837008 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Sun, 17 May 2009 09:42:56 -0700 Subject: [PATCH] support resource errors for out of memory conditions. improve stack dump message. --- C/errors.c | 104 ++++++++++++++++++++++------------------------------- H/iatoms.h | 5 ++- H/ratoms.h | 5 ++- H/tatoms.h | 10 ++++-- misc/ATOMS | 5 ++- 5 files changed, 62 insertions(+), 67 deletions(-) diff --git a/C/errors.c b/C/errors.c index 60f5b46b3..ae55a56f5 100644 --- a/C/errors.c +++ b/C/errors.c @@ -196,65 +196,31 @@ detect_bug_location(yamop *yap_pc, find_pred_type where_from, char *tp, int psiz } else if (pred_module == 0) { /* don't give info on system predicates */ #if HAVE_SNPRINTF -#if SHORT_INTS - snprintf(tp, psize, "prolog:%s/%ld", - RepAtom(pred_name)->StrOfAE, pred_arity); + snprintf(tp, psize, "prolog:%s/%lu", + RepAtom(pred_name)->StrOfAE, (unsigned long int)pred_arity); #else - snprintf(tp, psize, "prolog:%s/%d", - RepAtom(pred_name)->StrOfAE, pred_arity); -#endif -#else -#if SHORT_INTS - sprintf(tp, "in prolog:%s/%ld", - RepAtom(pred_name)->StrOfAE, pred_arity); -#else - sprintf(tp, "in prolog:%s/%d", - RepAtom(pred_name)->StrOfAE, pred_arity); -#endif + sprintf(tp, "in prolog:%s/%lu", + RepAtom(pred_name)->StrOfAE, (unsigned long int)pred_arity); #endif } else if (cl < 0) { #if HAVE_SNPRINTF -#if SHORT_INTS - snprintf(tp, psize, "indexing code of %s:%s/%ld", + snprintf(tp, psize, "%s:%s/%lu", RepAtom(AtomOfTerm(pred_module))->StrOfAE, - RepAtom(pred_name)->StrOfAE, pred_arity); + RepAtom(pred_name)->StrOfAE, (unsigned long int)pred_arity); #else - snprintf(tp, psize, "indexing code of %s:%s/%d", - RepAtom(AtomOfTerm(pred_module))->StrOfAE, - RepAtom(pred_name)->StrOfAE, pred_arity); -#endif -#else -#if SHORT_INTS - sprintf(tp, "indexing code of %s:%s/%ld", + sprintf(tp, "%s:%s/%lu", RepAtom(AtomOfTerm(pred_module))->StrOfAE, - RepAtom(pred_name)->StrOfAE, pred_arity); -#else - sprintf(tp, "indexing code of %s:%s/%d", - RepAtom(AtomOfTerm(pred_module))->StrOfAE, - RepAtom(pred_name)->StrOfAE, pred_arity); -#endif + RepAtom(pred_name)->StrOfAE, (unsigned long int)pred_arity); #endif } else { #if HAVE_SNPRINTF -#if SHORT_INTS - snprintf(tp, psize, "clause %ld of %s:%s/%ld", cl, + snprintf(tp, psize, "%s:%s/%lu at clause %lu ", RepAtom(AtomOfTerm(pred_module))->StrOfAE, - RepAtom(pred_name)->StrOfAE, pred_arity); + RepAtom(pred_name)->StrOfAE, (unsigned long int)pred_arity, (unsigned long int)cl); #else - snprintf(tp, psize, "clause %d of %s:%s/%d", cl, - RepAtom(AtomOfTerm(pred_module))->StrOfAE, - RepAtom(pred_name)->StrOfAE, pred_arity); -#endif -#else -#if SHORT_INTS - sprintf(tp, "clause %ld of %s:%s/%ld", cl, + sprintf(tp, "%s:%s/%lu at clause %lu", RepAtom(AtomOfTerm(pred_module))->StrOfAE, - RepAtom(pred_name)->StrOfAE, pred_arity); -#else - sprintf(tp, "clause %d of %s:%s/%d", cl, - RepAtom(AtomOfTerm(pred_module))->StrOfAE, - RepAtom(pred_name)->StrOfAE, pred_arity); -#endif + RepAtom(pred_name)->StrOfAE, (unsigned long int)pred_arity, (unsigned long int)cl); #endif } } @@ -291,10 +257,14 @@ dump_stack(void) } #endif #endif - fprintf (stderr,"%ldKB of Global Stack (%p--%p)\n",(long int)(sizeof(CELL)*(H-H0))/1024,H0,H); - fprintf (stderr,"%ldKB of Local Stack (%p--%p)\n",(long int)(sizeof(CELL)*(LCL0-ASP))/1024,ASP,LCL0); - fprintf (stderr,"%ldKB of Trail (%p--%p)\n",(long int)((ADDR)TR-Yap_TrailBase)/1024,Yap_TrailBase,TR); - fprintf (stderr,"Performed %d garbage collections\n", GcCalls); + detect_bug_location(P, FIND_PRED_FROM_ANYWHERE, (char *)H, 256); + fprintf (stderr,"%%\n%% PC: %s\n",(char *)H); + detect_bug_location(CP, FIND_PRED_FROM_ANYWHERE, (char *)H, 256); + fprintf (stderr,"%% Continuation: %s\n",(char *)H); + fprintf (stderr,"%% %ldKB of Global Stack (%p--%p)\n",(long int)(sizeof(CELL)*(H-H0))/1024,H0,H); + fprintf (stderr,"%% %ldKB of Local Stack (%p--%p)\n",(long int)(sizeof(CELL)*(LCL0-ASP))/1024,ASP,LCL0); + fprintf (stderr,"%% %ldKB of Trail (%p--%p)\n",(long int)((ADDR)TR-Yap_TrailBase)/1024,Yap_TrailBase,TR); + fprintf (stderr,"%% Performed %d garbage collections\n", GcCalls); #if LOW_LEVEL_TRACER { extern long long vsc_count; @@ -304,19 +274,17 @@ dump_stack(void) } } #endif - detect_bug_location(P, FIND_PRED_FROM_ANYWHERE, (char *)H, 256); - fprintf (stderr,"Running code at %s\n",(char *)H); - detect_bug_location(CP, FIND_PRED_FROM_ANYWHERE, (char *)H, 256); - fprintf (stderr,"Continuation is at %s\n",(char *)H); + fprintf (stderr,"%% All Active Calls and\n"); + fprintf (stderr,"%% Goals With Alternatives Open (Global In Use--Local In Use)\n%%\n"); while (b_ptr != NULL) { while (env_ptr && env_ptr <= (CELL *)b_ptr) { detect_bug_location(ipc, FIND_PRED_FROM_ENV, tp, 256); if (env_ptr == (CELL *)b_ptr && (choiceptr)env_ptr[E_CB] > b_ptr) { b_ptr = b_ptr->cp_b; - fprintf(stderr," %s (*)\n", tp); + fprintf(stderr,"%% %s\n", tp); } else { - fprintf(stderr," %s\n", tp); + fprintf(stderr,"%% %s\n", tp); } ipc = (yamop *)(env_ptr[E_CP]); env_ptr = (CELL *)(env_ptr[E_E]); @@ -328,7 +296,9 @@ dump_stack(void) b_ptr->cp_ap->opc != Yap_opcode(_Nstop)) { /* we can safely ignore ; because there is always an upper env */ detect_bug_location(b_ptr->cp_ap, FIND_PRED_FROM_CP, tp, 256); - fprintf(stderr," %s (*)\n", tp); + fprintf(stderr,"%% %s (%luKB--%luKB)\n", tp, + (unsigned long int)((b_ptr->cp_h-H0)*sizeof(CELL)/1024), + (unsigned long int)((ADDR)LCL0-(ADDR)b_ptr)/1024); } b_ptr = b_ptr->cp_b; } @@ -999,10 +969,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) case OUT_OF_HEAP_ERROR: { int i; + Term ti[1]; dump_stack(); + ti[0] = MkAtomTerm(AtomCodeSpace); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(AtomOutOfHeapError); + nt[0] = Yap_MkApplTerm(FunctorResourceError, 1, ti); tp = tmpbuf+i; psize -= i; fun = FunctorError; @@ -1012,10 +984,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) case OUT_OF_STACK_ERROR: { int i; + Term ti[1]; dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(AtomOutOfStackError); + ti[0] = MkAtomTerm(AtomStack); + nt[0] = Yap_MkApplTerm(FunctorResourceError, 1, ti); tp = tmpbuf+i; psize -= i; fun = FunctorError; @@ -1025,10 +999,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) case OUT_OF_ATTVARS_ERROR: { int i; + Term ti[1]; dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(AtomOutOfAttvarsError); + ti[0] = MkAtomTerm(AtomAttributes); + nt[0] = Yap_MkApplTerm(FunctorResourceError, 1, ti); tp = tmpbuf+i; psize -= i; fun = FunctorError; @@ -1038,11 +1014,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) case OUT_OF_AUXSPACE_ERROR: { int i; + Term ti[1]; dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(AtomOutOfAuxspaceError); tp = tmpbuf+i; + ti[0] = MkAtomTerm(AtomUnificationStack); + nt[0] = Yap_MkApplTerm(FunctorResourceError, 1, ti); psize -= i; fun = FunctorError; serious = TRUE; @@ -1051,10 +1029,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) case OUT_OF_TRAIL_ERROR: { int i; + Term ti[1]; dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(AtomOutOfTrailError); + ti[0] = MkAtomTerm(AtomTrail); + nt[0] = Yap_MkApplTerm(FunctorResourceError, 1, ti); tp = tmpbuf+i; psize -= i; fun = FunctorError; diff --git a/H/iatoms.h b/H/iatoms.h index 2c85dae5a..5516cb901 100644 --- a/H/iatoms.h +++ b/H/iatoms.h @@ -38,10 +38,11 @@ AtomCatch = Yap_FullLookupAtom("$catch"); AtomChangeModule = Yap_FullLookupAtom("$change_module"); AtomChar = Yap_LookupAtom("char"); + AtomCharsio = Yap_LookupAtom("charsio"); AtomCharacter = Yap_LookupAtom("character"); AtomCharacterCode = Yap_LookupAtom("character_code"); - AtomCharsio = Yap_LookupAtom("charsio"); AtomColomn = Yap_LookupAtom(":"); + AtomCodeSpace = Yap_LookupAtom("code_space"); AtomComma = Yap_LookupAtom(","); AtomCompound = Yap_LookupAtom("compound"); AtomConsistencyError = Yap_LookupAtom("consistency_error"); @@ -260,6 +261,7 @@ AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); + AtomTrail = Yap_LookupAtom("trail"); AtomTrue = Yap_LookupAtom("true"); AtomTty = Yap_LookupAtom("tty"); AtomTtys = Yap_LookupAtom("ttys"); @@ -267,6 +269,7 @@ AtomUndefined = Yap_LookupAtom("undefined"); AtomUndefp = Yap_FullLookupAtom("$undefp"); AtomUnderflow = Yap_LookupAtom("underflow"); + AtomUnificationStack = Yap_LookupAtom("unification_stack"); AtomUnsignedByte = Yap_LookupAtom("unsigned_byte"); AtomUnsignedChar = Yap_LookupAtom("unsigned_char"); AtomUser = Yap_LookupAtom("user"); diff --git a/H/ratoms.h b/H/ratoms.h index c8e46fc1a..f69eb4819 100644 --- a/H/ratoms.h +++ b/H/ratoms.h @@ -38,10 +38,11 @@ AtomCatch = AtomAdjust(AtomCatch); AtomChangeModule = AtomAdjust(AtomChangeModule); AtomChar = AtomAdjust(AtomChar); + AtomCharsio = AtomAdjust(AtomCharsio); AtomCharacter = AtomAdjust(AtomCharacter); AtomCharacterCode = AtomAdjust(AtomCharacterCode); - AtomCharsio = AtomAdjust(AtomCharsio); AtomColomn = AtomAdjust(AtomColomn); + AtomCodeSpace = AtomAdjust(AtomCodeSpace); AtomComma = AtomAdjust(AtomComma); AtomCompound = AtomAdjust(AtomCompound); AtomConsistencyError = AtomAdjust(AtomConsistencyError); @@ -262,6 +263,7 @@ AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); + AtomTrail = AtomAdjust(AtomTrail); AtomTrue = AtomAdjust(AtomTrue); AtomTty = AtomAdjust(AtomTty); AtomTtys = AtomAdjust(AtomTtys); @@ -269,6 +271,7 @@ AtomUndefined = AtomAdjust(AtomUndefined); AtomUndefp = AtomAdjust(AtomUndefp); AtomUnderflow = AtomAdjust(AtomUnderflow); + AtomUnificationStack = AtomAdjust(AtomUnificationStack); AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); AtomUser = AtomAdjust(AtomUser); diff --git a/H/tatoms.h b/H/tatoms.h index bd29921f6..f1e902e85 100644 --- a/H/tatoms.h +++ b/H/tatoms.h @@ -78,14 +78,16 @@ #define AtomChangeModule Yap_heap_regs->AtomChangeModule_ Atom AtomChar_; #define AtomChar Yap_heap_regs->AtomChar_ + Atom AtomCharsio_; +#define AtomCharsio Yap_heap_regs->AtomCharsio_ Atom AtomCharacter_; #define AtomCharacter Yap_heap_regs->AtomCharacter_ Atom AtomCharacterCode_; #define AtomCharacterCode Yap_heap_regs->AtomCharacterCode_ - Atom AtomCharsio_; -#define AtomCharsio Yap_heap_regs->AtomCharsio_ Atom AtomColomn_; #define AtomColomn Yap_heap_regs->AtomColomn_ + Atom AtomCodeSpace_; +#define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_ Atom AtomComma_; #define AtomComma Yap_heap_regs->AtomComma_ Atom AtomCompound_; @@ -526,6 +528,8 @@ #define AtomTopLevelGoal Yap_heap_regs->AtomTopLevelGoal_ Atom AtomTopThreadGoal_; #define AtomTopThreadGoal Yap_heap_regs->AtomTopThreadGoal_ + Atom AtomTrail_; +#define AtomTrail Yap_heap_regs->AtomTrail_ Atom AtomTrue_; #define AtomTrue Yap_heap_regs->AtomTrue_ Atom AtomTty_; @@ -540,6 +544,8 @@ #define AtomUndefp Yap_heap_regs->AtomUndefp_ Atom AtomUnderflow_; #define AtomUnderflow Yap_heap_regs->AtomUnderflow_ + Atom AtomUnificationStack_; +#define AtomUnificationStack Yap_heap_regs->AtomUnificationStack_ Atom AtomUnsignedByte_; #define AtomUnsignedByte Yap_heap_regs->AtomUnsignedByte_ Atom AtomUnsignedChar_; diff --git a/misc/ATOMS b/misc/ATOMS index a2e9c1a53..95daa53f7 100644 --- a/misc/ATOMS +++ b/misc/ATOMS @@ -47,10 +47,11 @@ A Callable N "callable" A Catch F "$catch" A ChangeModule F "$change_module" A Char N "char" +A Charsio N "charsio" A Character N "character" A CharacterCode N "character_code" -A Charsio N "charsio" A Colomn N ":" +A CodeSpace N "code_space" A Comma N "," A Compound N "compound" A ConsistencyError N "consistency_error" @@ -271,6 +272,7 @@ A Throw N "throw" A TimeOutSpec N "time_out_spec" A TopLevelGoal F "$top_level_goal" A TopThreadGoal F "$top_thread_goal" +A Trail N "trail" A True N "true" A Tty N "tty" A Ttys N "ttys" @@ -278,6 +280,7 @@ A TypeError N "type_error" A Undefined N "undefined" A Undefp F "$undefp" A Underflow N "underflow" +A UnificationStack N "unification_stack" A UnsignedByte N "unsigned_byte" A UnsignedChar N "unsigned_char" A User N "user"