Datasets:

---

iNeil77

/

the-vault-function

like 0

[ "MIT" ]

[ "Check", "if", "processor", "has", "BTS", "capabilities" ]

[ "int", "check_has_bts", "(", ")", "{", "INT64", "msr", ";", "debug", "(", "\"", "\"", ")", ";", "msr", "=", "__readmsr", "(", "MSR_MISC", ")", ";", "if", "(", "CHECK_BIT", "(", "msr", ",", "BTS_BIT_OFFSET", ")", "==", "BIT_ENABLED", ")", "{", "return", "CPU_HAS_NO_BTS", ";", "}", "return", "NO_ERROR", ";", "}" ]

[ "Check", "if", "processor", "has", "BTS", "capabilities" ]

[ "/* IA32_MISC_MSR - 416 */", "/* MSR[11]=1 */" ]

[]

[ "MIT" ]

[ "check", "if", "a", "part", "of", "the", "snake", "is", "on", "the", "given", "spot", "returns", "a", "WINDOW", "*", "if", "one", "is", "found", "NULL", "if", "not" ]

[ "WINDOW", "*", "snake_part_is_on", "(", "SNAKE", "*", "snake", ",", "int", "posy", ",", "int", "posx", ")", "{", "int", "i", ";", "int", "cury", ",", "curx", ";", "for", "(", "i", "=", "0", ";", "i", "<", "snake", "->", "length", ";", "i", "++", ")", "{", "getbegyx", "(", "snake", "->", "parts", "[", "i", "]", ",", "cury", ",", "curx", ")", ";", "if", "(", "cury", "==", "posy", "&&", "curx", "==", "posx", ")", "{", "return", "snake", "->", "parts", "[", "i", "]", ";", "}", "}", "return", "NULL", ";", "}" ]

[ "check", "if", "a", "part", "of", "the", "snake", "is", "on", "the", "given", "spot", "returns", "a", "WINDOW", "*", "if", "one", "is", "found", "NULL", "if", "not" ]

[ "// position of the current snake part we are iterating", "// iterate each part", "// get the position of the current part", "// compare the position", "// return the current part" ]

[ { "param": "snake", "type": "SNAKE" }, { "param": "posy", "type": "int" }, { "param": "posx", "type": "int" } ]

[ "MIT" ]

[ "increase", "the", "length", "of", "the", "name", "by", "one" ]

[ "void", "grow_snake", "(", "SNAKE", "*", "snake", ",", "int", "posy", ",", "int", "posx", ")", "{", "WINDOW", "*", "win", ";", "snake", "->", "length", "++", ";", "if", "(", "snake", "->", "length", "==", "0", ")", "{", "snake", "->", "parts", "=", "malloc", "(", "sizeof", "(", "WINDOW", "*", ")", "*", "snake", "->", "length", ")", ";", "}", "else", "{", "snake", "->", "parts", "=", "realloc", "(", "snake", "->", "parts", ",", "sizeof", "(", "WINDOW", "*", ")", "*", "snake", "->", "length", ")", ";", "}", "snake", "->", "parts", "[", "snake", "->", "length", "-", "1", "]", "=", "win", "=", "newwin", "(", "1", ",", "1", ",", "posy", ",", "posx", ")", ";", "wattron", "(", "win", ",", "COLOR_PAIR", "(", "2", ")", ")", ";", "wprintw", "(", "win", ",", "\"", "\"", ",", "'", "'", ")", ";", "wrefresh", "(", "win", ")", ";", "return", ";", "}" ]

[ "increase", "the", "length", "of", "the", "name", "by", "one" ]

[ "// a window containing a single char of a snake", "// increase the length of the snake", "// allocate memory for the new part", "// initialize the array with malloc if it is the first part", "// increase the amount of allocated memory", "// create a new window", "// print the character on the window", "// display the part" ]

[ { "param": "snake", "type": "SNAKE" }, { "param": "posy", "type": "int" }, { "param": "posx", "type": "int" } ]

[ "MIT" ]

[ "free", "the", "allocated", "memory", "for", "the", "snake" ]

[ "void", "kill_snake", "(", "SNAKE", "*", "snake", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "snake", "->", "length", ";", "i", "++", ")", "{", "delwin", "(", "snake", "->", "parts", "[", "i", "]", ")", ";", "}", "free", "(", "snake", "->", "parts", ")", ";", "return", ";", "}" ]

[ "free", "the", "allocated", "memory", "for", "the", "snake" ]

[ "// delete each created window of the snake", "// free the resources allocated for the window pointers" ]

[ { "param": "snake", "type": "SNAKE" } ]

[ "MIT" ]

[ "calculate", "the", "difference", "between", "two", "timespec", "structs" ]

[ "long", "long", "timeval_diff", "(", "struct", "timespec", "*", "tv1", ",", "struct", "timespec", "*", "tv2", ")", "{", "long", "long", "diff", "=", "0", ";", "long", "nano", "=", "(", "tv2", "->", "tv_nsec", "-", "tv1", "->", "tv_nsec", ")", ";", "int", "add", "=", "0", ";", "if", "(", "nano", "<", "0", ")", "{", "nano", "=", "1000000000", "+", "nano", ";", "add", "=", "1", ";", "}", "diff", "=", "nano", ";", "diff", "+=", "(", "tv2", "->", "tv_sec", "-", "tv1", "->", "tv_sec", "-", "add", ")", "*", "1000000000", ";", "return", "diff", ";", "}" ]

[ "calculate", "the", "difference", "between", "two", "timespec", "structs" ]

[ "// calculate the diffrence of the nanoseconds", "// some calculations if the nanoseconds of struct 1 were bigger", "// add the seconds" ]

[ { "param": "tv1", "type": "struct timespec" }, { "param": "tv2", "type": "struct timespec" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "drawArray", "File", ":", "sim", ".", "c", "Draws", "specified", "maze", "using", "drawMode", "color", "pair", "onto", "the", "screen", ".", "Parameter", "Descriptions", ":", "name", "description", "arr", "array", "containing", "maze", "drawMode", "color", "pair", "to", "use", "when", "drawing", "maze" ]

[ "void", "drawArray", "(", "int", "arr", ",", "int", "drawMode", ")", "{", "int", "row", ",", "col", ",", "value", ";", "attron", "(", "COLOR_PAIR", "(", "drawMode", ")", ")", ";", "for", "(", "row", "=", "0", ";", "row", "<", "MAZE_WIDTH", ";", "row", "++", ")", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", ";", "col", "++", ")", "{", "if", "(", "arr", "==", "ARRAY_MOUSEMAZE", ")", "value", "=", "getMouseMaze", "(", "row", ",", "col", ")", ";", "else", "if", "(", "arr", "==", "ARRAY_FLOODMAZE", ")", "value", "=", "getFloodMaze", "(", "row", ",", "col", ")", ";", "else", "if", "(", "arr", "==", "ARRAY_ACTUALMAZE", ")", "value", "=", "actualMaze", "[", "row", "]", "[", "col", "]", ";", "mvprintw", "(", "MAZE_START_ROW", "+", "row", "*", "2", "+", "1", ",", "MAZE_START_COL", "+", "col", "*", "3", "+", "1", ",", "\"", "\"", ",", "value", ")", ";", "}", "attroff", "(", "COLOR_PAIR", "(", "drawMode", ")", ")", ";", "}" ]

[ "Routine", "Name", ":", "drawArray", "File", ":", "sim", ".", "c" ]

[]

[ { "param": "arr", "type": "int" }, { "param": "drawMode", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "runMouse", "File", ":", "sim", ".", "c", "Interface", "used", "to", "call", "mouse", "functions", ".", "Parameter", "Descriptions", ":", "name", "description", "mouseMode", "mode", "mouse", "is", "in", "drawMode", "color", "pair", "to", "color", "tile", "walls", "that", "were", "just", "updated" ]

[ "void", "runMouse", "(", "int", "mouseMode", ",", "int", "drawMode", ")", "{", "int", "curRow", ",", "curCol", ";", "curRow", "=", "getMouseRow", "(", ")", ";", "curCol", "=", "getMouseCol", "(", ")", ";", "if", "(", "mouseMode", "==", "SPEED", ")", "{", "buildSpeedPath", "(", "8", ",", "8", ")", ";", "speedRun", "(", "8", ",", "8", ")", ";", "return", ";", "}", "else", "if", "(", "mouseMode", "==", "MAPPING", ")", "mapMaze", "(", "8", ",", "8", ",", "STEP", ")", ";", "else", "if", "(", "mouseMode", "==", "OPTIMIZING", ")", "mapMaze", "(", "15", ",", "0", ",", "STEP", ")", ";", "drawTileWalls", "(", "curCol", ",", "curRow", ",", "getMouseMaze", "(", "curRow", ",", "curCol", ")", ",", "drawMode", ")", ";", "drawMouse", "(", "curRow", ",", "curCol", ")", ";", "}" ]

[ "Routine", "Name", ":", "runMouse", "File", ":", "sim", ".", "c" ]

[]

[ { "param": "mouseMode", "type": "int" }, { "param": "drawMode", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "drawMouse", "File", ":", "sim", ".", "c", "Draws", "mouse", "marker", "on", "maze", "Parameter", "Descriptions", ":", "name", "description", "mouseRow", "row", "of", "mouse", "mouseCol", "col", "of", "mouse" ]

[ "void", "drawMouse", "(", "int", "mouseRow", ",", "int", "mouseCol", ")", "{", "int", "row", ",", "col", ";", "for", "(", "row", "=", "0", ";", "row", "<", "MAZE_WIDTH", ";", "row", "++", ")", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", ";", "col", "++", ")", "mvaddch", "(", "MAZE_START_ROW", "+", "row", "*", "2", "+", "1", ",", "MAZE_START_COL", "+", "col", "*", "3", "+", "1", ",", "'", "'", ")", ";", "mvaddch", "(", "MAZE_START_ROW", "+", "mouseRow", "*", "2", "+", "1", ",", "MAZE_START_COL", "+", "mouseCol", "*", "3", "+", "1", ",", "ACS_DIAMOND", ")", ";", "}" ]

[ "Routine", "Name", ":", "drawMouse", "File", ":", "sim", ".", "c" ]

[]

[ { "param": "mouseRow", "type": "int" }, { "param": "mouseCol", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "printMenu", "File", ":", "sim", ".", "c", "Displays", "status", "bar", "to", "side", "of", "maze", "Parameter", "Descriptions", ":", "name", "description", "mode", "color", "pair", "used", "to", "draw", "menu" ]

[ "void", "printMenu", "(", "int", "mode", ")", "{", "int", "row", ",", "col", ",", "i", ";", "row", "=", "MAZE_START_ROW", ";", "col", "=", "MAZE_START_COL", "+", "MAZE_WIDTH", "*", "3", "+", "3", ";", "attron", "(", "COLOR_PAIR", "(", "mode", ")", ")", ";", "mvaddch", "(", "row", ",", "col", ",", "ACS_ULCORNER", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "MENU_WIDTH", "-", "2", ";", "i", "++", ")", "{", "addch", "(", "ACS_HLINE", ")", ";", "}", "addch", "(", "ACS_URCORNER", ")", ";", "for", "(", "i", "=", "row", "+", "1", ";", "i", "<", "MENU_HEIGHT", ";", "i", "++", ")", "{", "mvaddch", "(", "i", ",", "col", ",", "ACS_VLINE", ")", ";", "mvaddch", "(", "i", ",", "col", "+", "MENU_WIDTH", "-", "1", ",", "ACS_VLINE", ")", ";", "}", "mvaddch", "(", "row", "+", "MENU_HEIGHT", "-", "1", ",", "col", ",", "ACS_LLCORNER", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "MENU_WIDTH", "-", "2", ";", "i", "++", ")", "{", "addch", "(", "ACS_HLINE", ")", ";", "}", "addch", "(", "ACS_LRCORNER", ")", ";", "mvprintw", "(", "row", "+", "1", ",", "col", "+", "1", ",", "\"", "\"", ")", ";", "mvprintw", "(", "row", "+", "2", ",", "col", "+", "1", ",", "\"", "\"", ")", ";", "mvprintw", "(", "row", "+", "3", ",", "col", "+", "1", ",", "\"", "\"", ")", ";", "mvprintw", "(", "row", "+", "4", ",", "col", "+", "1", ",", "\"", "\"", ")", ";", "mvprintw", "(", "row", "+", "5", ",", "col", "+", "1", ",", "\"", "\"", ")", ";", "mvprintw", "(", "row", "+", "6", ",", "col", "+", "1", ",", "\"", "\"", ")", ";", "mvprintw", "(", "row", "+", "7", ",", "col", "+", "1", ",", "\"", "\"", ")", ";", "mvprintw", "(", "row", "+", "8", ",", "col", "+", "1", ",", "\"", "\"", ")", ";", "attroff", "(", "COLOR_PAIR", "(", "mode", ")", ")", ";", "}" ]

[ "Routine", "Name", ":", "printMenu", "File", ":", "sim", ".", "c" ]

[ "//Print menu box", "//Print menu" ]

[ { "param": "mode", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "printMaze", "File", ":", "sim", ".", "c", "Prints", "maze", "to", "screen", "using", "color", "pair", "specified", ".", "Parameter", "Descriptions", ":", "name", "description", "maze", "maze", "in", "array", "form", "to", "print", "mode", "color", "pair", "to", "use" ]

[ "void", "printMaze", "(", "int", "maze", "[", "MAZE_WIDTH", "]", "[", "MAZE_WIDTH", "]", ",", "int", "mode", ")", "{", "int", "row", ",", "col", ";", "attron", "(", "COLOR_PAIR", "(", "mode", ")", ")", ";", "for", "(", "row", "=", "0", ";", "row", "<", "MAZE_WIDTH", ";", "row", "++", ")", "{", "move", "(", "row", ",", "0", ")", ";", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", ";", "col", "++", ")", "printw", "(", "\"", "\"", ",", "maze", "[", "row", "]", "[", "col", "]", ")", ";", "}", "attroff", "(", "COLOR_PAIR", "(", "mode", ")", ")", ";", "}" ]

[ "Routine", "Name", ":", "printMaze", "File", ":", "sim", ".", "c" ]

[]

[ { "param": "maze", "type": "int" }, { "param": "mode", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "drawTileWalls", "File", ":", "sim", ".", "c", "Draws", "walls", "of", "specified", "color", "for", "tile", "at", "given", "coordinates", "Parameter", "Descriptions", ":", "name", "description", "xTile", "x", "location", "of", "tile", "yTile", "y", "location", "of", "tile", "walls", "wall", "information", "mode", "color", "pair", "to", "use" ]

[ "void", "drawTileWalls", "(", "int", "xTile", ",", "int", "yTile", ",", "int", "walls", ",", "int", "mode", ")", "{", "int", "xDraw", ",", "yDraw", ";", "xDraw", "=", "MAZE_START_COL", "+", "xTile", "*", "3", "+", "1", ";", "yDraw", "=", "MAZE_START_ROW", "+", "yTile", "*", "2", "+", "1", ";", "attron", "(", "COLOR_PAIR", "(", "mode", ")", ")", ";", "if", "(", "(", "walls", "&", "LEFT_WALL", ")", "==", "LEFT_WALL", ")", "{", "mvaddch", "(", "yDraw", ",", "xDraw", "-", "1", ",", "ACS_VLINE", ")", ";", "}", "if", "(", "(", "walls", "&", "RIGHT_WALL", ")", "==", "RIGHT_WALL", ")", "{", "mvaddch", "(", "yDraw", ",", "xDraw", "+", "2", ",", "ACS_VLINE", ")", ";", "}", "if", "(", "(", "walls", "&", "UPPER_WALL", ")", "==", "UPPER_WALL", ")", "{", "mvaddch", "(", "yDraw", "-", "1", ",", "xDraw", ",", "ACS_HLINE", ")", ";", "addch", "(", "ACS_HLINE", ")", ";", "}", "if", "(", "(", "walls", "&", "LOWER_WALL", ")", "==", "LOWER_WALL", ")", "{", "mvaddch", "(", "yDraw", "+", "1", ",", "xDraw", ",", "ACS_HLINE", ")", ";", "addch", "(", "ACS_HLINE", ")", ";", "}", "attroff", "(", "COLOR_PAIR", "(", "mode", ")", ")", ";", "}" ]

[ "Routine", "Name", ":", "drawTileWalls", "File", ":", "sim", ".", "c" ]

[]

[ { "param": "xTile", "type": "int" }, { "param": "yTile", "type": "int" }, { "param": "walls", "type": "int" }, { "param": "mode", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "drawMaze", "File", ":", "sim", ".", "c", "Draws", "either", "full", "or", "empty", "maze", "Parameter", "Descriptions", ":", "name", "description", "type", "full", "or", "empty", "mode", "color", "pair", "to", "use" ]

[ "void", "drawMaze", "(", "int", "type", ",", "int", "mode", ")", "{", "int", "row", ",", "col", ";", "attron", "(", "COLOR_PAIR", "(", "mode", ")", ")", ";", "if", "(", "type", "==", "FULL", ")", "{", "for", "(", "row", "=", "MAZE_START_ROW", ";", "row", "<=", "MAZE_START_ROW", "+", "MAZE_WIDTH", "*", "2", ";", "row", "++", ")", "{", "move", "(", "row", ",", "MAZE_START_COL", ")", ";", "if", "(", "row", "%", "2", "==", "0", ")", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", "+", "1", ";", "col", "++", ")", "mvaddch", "(", "row", ",", "MAZE_START_COL", "+", "col", "*", "3", ",", "ACS_VLINE", ")", ";", "else", "{", "addch", "(", "ACS_BULLET", ")", ";", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", ";", "col", "++", ")", "{", "addch", "(", "ACS_HLINE", ")", ";", "addch", "(", "ACS_HLINE", ")", ";", "addch", "(", "ACS_BULLET", ")", ";", "}", "}", "}", "}", "else", "if", "(", "type", "==", "EMPTY", ")", "{", "row", "=", "MAZE_START_ROW", ";", "col", "=", "MAZE_START_COL", ";", "for", "(", "row", "=", "MAZE_START_ROW", ";", "row", "<=", "MAZE_START_ROW", "+", "MAZE_WIDTH", "*", "2", ";", "row", "++", ")", "{", "if", "(", "row", "==", "MAZE_START_ROW", "||", "row", "==", "MAZE_START_ROW", "+", "MAZE_WIDTH", "*", "2", ")", "{", "move", "(", "row", ",", "MAZE_START_COL", ")", ";", "addch", "(", "ACS_BULLET", ")", ";", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", ";", "col", "++", ")", "{", "addch", "(", "ACS_HLINE", ")", ";", "addch", "(", "ACS_HLINE", ")", ";", "addch", "(", "ACS_BULLET", ")", ";", "}", "}", "else", "if", "(", "row", "%", "2", "==", "0", ")", "{", "mvaddch", "(", "row", ",", "MAZE_START_COL", ",", "ACS_VLINE", ")", ";", "mvaddch", "(", "row", ",", "MAZE_START_COL", "+", "MAZE_WIDTH", "*", "3", ",", "ACS_VLINE", ")", ";", "}", "else", "{", "for", "(", "col", "=", "0", ";", "col", "<=", "MAZE_WIDTH", ";", "col", "++", ")", "{", "mvaddch", "(", "row", ",", "MAZE_START_COL", "+", "col", "*", "3", ",", "ACS_BULLET", ")", ";", "}", "}", "}", "}", "attroff", "(", "COLOR_PAIR", "(", "mode", ")", ")", ";", "}" ]

[ "Routine", "Name", ":", "drawMaze", "File", ":", "sim", ".", "c" ]

[ "//move cursor to beginning of row" ]

[ { "param": "type", "type": "int" }, { "param": "mode", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "initMaze", "File", ":", "sim", ".", "c", "Initializes", "maze", "with", "file", "containing", "wall", "information", "Parameter", "Descriptions", ":", "name", "description", "maze", "array", "to", "fill", "mazeStr", "file", "containing", "wall", "info" ]

[ "void", "initMaze", "(", "int", "maze", "[", "MAZE_WIDTH", "]", "[", "MAZE_WIDTH", "]", ",", "char", "*", "mazeStr", ")", "{", "FILE", "*", "mazeFile", ";", "int", "row", ",", "col", ",", "wall", ";", "mazeFile", "=", "fopen", "(", "mazeStr", ",", "\"", "\"", ")", ";", "for", "(", "row", "=", "0", ";", "row", "<", "MAZE_WIDTH", ";", "row", "++", ")", "{", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", ";", "col", "++", ")", "{", "fscanf", "(", "mazeFile", ",", "\"", "\"", ",", "&", "wall", ")", ";", "maze", "[", "row", "]", "[", "col", "]", "=", "wall", ";", "}", "}", "fclose", "(", "mazeFile", ")", ";", "}" ]

[ "Routine", "Name", ":", "initMaze", "File", ":", "sim", ".", "c" ]

[]

[ { "param": "maze", "type": "int" }, { "param": "mazeStr", "type": "char" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "initMouse", "File", ":", "mouse", ".", "c", "Initializes", "mouse", "with", "the", "starting", "location", "Parameter", "Descriptions", ":", "name", "description", "startRow", "mouse", "start", "row", "startCol", "mouse", "start", "column" ]

[ "void", "initMouse", "(", "int", "startRow", ",", "int", "startCol", ")", "{", "int", "row", ",", "col", ";", "curRow", "=", "startRow", ";", "curCol", "=", "startCol", ";", "for", "(", "row", "=", "0", ";", "row", "<", "MAZE_WIDTH", ";", "row", "++", ")", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", ";", "col", "++", ")", "{", "mouseMaze", "[", "row", "]", "[", "col", "]", "=", "0", ";", "floodMaze", "[", "row", "]", "[", "col", "]", "=", "MAZE_WIDTH", "*", "MAZE_WIDTH", "-", "1", ";", "}", "queueTop", "=", "0", ";", "}" ]

[ "Routine", "Name", ":", "initMouse", "File", ":", "mouse", ".", "c" ]

[]

[ { "param": "startRow", "type": "int" }, { "param": "startCol", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "mapMaze", "File", ":", "mouse", ".", "c", "Traverse", "through", "maze", "until", "at", "target", "location", ".", "Parameter", "Descriptions", ":", "name", "description", "targetRow", "target", "location", "row", "targetCol", "target", "location", "column", "mode", "if", "step", "only", "takes", "one", "step" ]

[ "void", "mapMaze", "(", "int", "targetRow", ",", "int", "targetCol", ",", "int", "mode", ")", "{", "int", "curLoc", ";", "int", "atDest", ";", "destRow", "=", "targetRow", ";", "destCol", "=", "targetCol", ";", "floodFill", "(", "0", ",", "targetRow", ",", "targetCol", ")", ";", "do", "{", "curLoc", "=", "mouseMaze", "[", "curRow", "]", "[", "curCol", "]", ";", "scanWalls", "(", "curRow", ",", "curCol", ")", ";", "validateFlood", "(", "curRow", ",", "curCol", ")", ";", "mouseMove", "(", "FLOOD", ",", "0", ",", "0", ")", ";", "if", "(", "mode", "==", "STEP", ")", "return", ";", "atDest", "=", "atLoc", "(", "targetRow", ",", "targetCol", ")", ";", "}", "while", "(", "atDest", "==", "0", ")", ";", "}" ]

[ "Routine", "Name", ":", "mapMaze", "File", ":", "mouse", ".", "c" ]

[ "//read wall info", "//floodfill", "//move", "//if(curLoc != mouseMaze[curRow][curCol]) {", "//updateFlood(curRow, curCol);", "//floodFromQueue();", "//}", "//closeBoxes();" ]

[ { "param": "targetRow", "type": "int" }, { "param": "targetCol", "type": "int" }, { "param": "mode", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "atLoc", "File", ":", "mouse", ".", "c", "Returns", "1", "(", "true", ")", "if", "mouse", "is", "at", "location", "specified", "Parameter", "Descriptions", ":", "name", "description", "row", "target", "location", "row", "col", "target", "location", "column" ]

[ "int", "atLoc", "(", "int", "row", ",", "int", "col", ")", "{", "if", "(", "curRow", "==", "row", "&&", "curCol", "==", "col", ")", "return", "1", ";", "return", "0", ";", "}" ]

[ "Routine", "Name", ":", "atLoc", "File", ":", "mouse", ".", "c" ]

[]

[ { "param": "row", "type": "int" }, { "param": "col", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "scanWalls", "File", ":", "mouse", ".", "c", "References", "actual", "maze", "for", "wall", "information", "and", "updates", "mouse", "'", "s", "memory", "with", "appropriate", "walls", ".", "Parameter", "Descriptions", ":", "name", "description", "row", "row", "of", "tile", "to", "update", "col", "column", "of", "tile", "to", "update" ]

[ "void", "scanWalls", "(", "int", "row", ",", "int", "col", ")", "{", "int", "actualWall", ";", "actualWall", "=", "getActualMaze", "(", "row", ",", "col", ")", ";", "if", "(", "actualWall", "&", "LEFT_WALL", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "LEFT_WALL", ")", "==", "0", ")", "{", "mouseMaze", "[", "row", "]", "[", "col", "]", "|=", "LEFT_WALL", ";", "if", "(", "col", ">", "0", ")", "mouseMaze", "[", "row", "]", "[", "col", "-", "1", "]", "|=", "RIGHT_WALL", ";", "}", "if", "(", "actualWall", "&", "RIGHT_WALL", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "RIGHT_WALL", ")", "==", "0", ")", "{", "mouseMaze", "[", "row", "]", "[", "col", "]", "|=", "RIGHT_WALL", ";", "if", "(", "col", "<", "MAZE_WIDTH", "-", "1", ")", "mouseMaze", "[", "row", "]", "[", "col", "+", "1", "]", "|=", "LEFT_WALL", ";", "}", "if", "(", "actualWall", "&", "UPPER_WALL", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "UPPER_WALL", ")", "==", "0", ")", "{", "mouseMaze", "[", "row", "]", "[", "col", "]", "|=", "UPPER_WALL", ";", "if", "(", "row", ">", "0", ")", "mouseMaze", "[", "row", "-", "1", "]", "[", "col", "]", "|=", "LOWER_WALL", ";", "}", "if", "(", "actualWall", "&", "LOWER_WALL", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "LOWER_WALL", ")", "==", "0", ")", "{", "mouseMaze", "[", "row", "]", "[", "col", "]", "|=", "LOWER_WALL", ";", "if", "(", "row", "<", "MAZE_WIDTH", "-", "1", ")", "mouseMaze", "[", "row", "+", "1", "]", "[", "col", "]", "|=", "UPPER_WALL", ";", "}", "}" ]

[ "Routine", "Name", ":", "scanWalls", "File", ":", "mouse", ".", "c" ]

[]

[ { "param": "row", "type": "int" }, { "param": "col", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "updateFlood", "File", ":", "mouse", ".", "c", "Updates", "floodfill", "maze", "starting", "from", "specified", "tile", "Parameter", "Descriptions", ":", "name", "description", "row", "row", "of", "tile", "to", "start", "from", "col", "column", "of", "tile", "to", "start", "from" ]

[ "void", "updateFlood", "(", "int", "row", ",", "int", "col", ")", "{", "int", "lower", ",", "higher", ",", "nonNeighbor", ";", "lower", "=", "findLowerNeighbor", "(", "row", ",", "col", ")", ";", "if", "(", "lower", "!=", "0", ")", "{", "floodQueue", "[", "queueTop", "]", "[", "0", "]", "=", "row", ";", "floodQueue", "[", "queueTop", "]", "[", "1", "]", "=", "col", ";", "queueTop", "++", ";", "}", "else", "{", "higher", "=", "lower", "^", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "WALLS", ")", ";", "floodMaze", "[", "row", "]", "[", "col", "]", "=", "MAZE_WIDTH", "*", "MAZE_WIDTH", "-", "1", ";", "if", "(", "(", "higher", "&", "LEFT", ")", "!=", "LEFT", ")", "updateFlood", "(", "row", ",", "col", "-", "1", ")", ";", "if", "(", "(", "higher", "&", "UP", ")", "!=", "UP", ")", "updateFlood", "(", "row", "-", "1", ",", "col", ")", ";", "if", "(", "(", "higher", "&", "RIGHT", ")", "!=", "RIGHT", ")", "updateFlood", "(", "row", ",", "col", "+", "1", ")", ";", "if", "(", "(", "higher", "&", "DOWN", ")", "!=", "DOWN", ")", "updateFlood", "(", "row", "+", "1", ",", "col", ")", ";", "}", "}" ]

[ "Routine", "Name", ":", "updateFlood", "File", ":", "mouse", ".", "c" ]

[ "//search for lower neighbors that this tile depends on", "//found at least 1 lower neighbor", "//add self to flood queue", "//find all higher flood value neighbors", "//reset current tile flood", "//for each higher flood neighbor, recursively update flooding", "/*\n if((lower & LEFT) != LEFT)\n updateFlood(row, col - 1);\n if((lower & UP) != UP)\n updateFlood(row - 1, col);\n if((lower & RIGHT) != RIGHT)\n updateFlood(row, col + 1);\n if((lower & DOWN) != DOWN)\n updateFlood(row + 1, col);\n */", "/*\n nonNeighbor = (lower | higher) ^ WALLS;\n \n if(nonNeighbor != 0) {\n \n }\n */", "//update non-neighbor tiles that depended on this tile", "/*\n if() {\n if(floodMaze[row - 1][col] > floodMaze[row][col])\n updateFlood(row - 1, col);\n if(floodMaze[row + 1][col] > floodMaze[row][col])\n updateFlood(row + 1, col);\n if(floodMaze[row][col - 1] > floodMaze[row][col])\n updateFlood(row, col - 1);\n if(floodMaze[row][col + 1] > floodMaze[row][col])\n updateFlood(row, col + 1);\n }\n */" ]

[ { "param": "row", "type": "int" }, { "param": "col", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "floodFromQueue", "File", ":", "mouse", ".", "c", "Starts", "a", "floodfill", "update", "from", "each", "value", "in", "floodQueue" ]

[ "void", "floodFromQueue", "(", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "queueTop", ";", "i", "++", ")", "{", "floodFill", "(", "floodMaze", "[", "floodQueue", "[", "i", "]", "[", "0", "]", "]", "[", "floodQueue", "[", "i", "]", "[", "1", "]", "]", ",", "floodQueue", "[", "i", "]", "[", "0", "]", ",", "floodQueue", "[", "i", "]", "[", "1", "]", ")", ";", "}", "queueTop", "=", "0", ";", "}" ]

[ "Routine", "Name", ":", "floodFromQueue", "File", ":", "mouse", ".", "c" ]

[ "//for each value in array, flood from location" ]

[]

[ "MIT" ]

[ "Routine", "Name", ":", "validateFlood", "File", ":", "mouse", ".", "c", "Ensures", "that", "the", "flood", "at", "a", "particular", "tile", "is", "valid", ".", "If", "not", "it", "validates", "the", "tile", "and", "validates", "its", "neighbors", ".", "Parameter", "Descriptions", ":", "name", "description", "row", "row", "of", "tile", "to", "validate", "col", "column", "of", "tile", "to", "validate" ]

[ "void", "validateFlood", "(", "int", "row", ",", "int", "col", ")", "{", "int", "lower", ",", "lowest", ";", "if", "(", "row", "==", "destRow", "&&", "col", "==", "destCol", ")", "return", ";", "lower", "=", "findLowerNeighbor", "(", "row", ",", "col", ")", ";", "lowest", "=", "255", ";", "if", "(", "row", ">", "0", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "UPPER_WALL", ")", "!=", "UPPER_WALL", ")", "lowest", "=", "floodMaze", "[", "row", "-", "1", "]", "[", "col", "]", ";", "if", "(", "row", "<", "MAZE_WIDTH", "-", "1", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "LOWER_WALL", ")", "!=", "LOWER_WALL", "&&", "floodMaze", "[", "row", "+", "1", "]", "[", "col", "]", "<", "lowest", ")", "lowest", "=", "floodMaze", "[", "row", "+", "1", "]", "[", "col", "]", ";", "if", "(", "col", ">", "0", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "LEFT_WALL", ")", "!=", "LEFT_WALL", "&&", "floodMaze", "[", "row", "]", "[", "col", "-", "1", "]", "<", "lowest", ")", "lowest", "=", "floodMaze", "[", "row", "]", "[", "col", "-", "1", "]", ";", "if", "(", "col", "<", "MAZE_WIDTH", "-", "1", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "RIGHT_WALL", ")", "!=", "RIGHT_WALL", "&&", "floodMaze", "[", "row", "]", "[", "col", "+", "1", "]", "<", "lowest", ")", "lowest", "=", "floodMaze", "[", "row", "]", "[", "col", "+", "1", "]", ";", "if", "(", "floodMaze", "[", "row", "]", "[", "col", "]", "==", "lowest", "+", "1", ")", "return", ";", "floodMaze", "[", "row", "]", "[", "col", "]", "=", "lowest", "+", "1", ";", "if", "(", "row", ">", "0", ")", "validateFlood", "(", "row", "-", "1", ",", "col", ")", ";", "if", "(", "row", "<", "MAZE_WIDTH", "-", "1", ")", "validateFlood", "(", "row", "+", "1", ",", "col", ")", ";", "if", "(", "col", ">", "0", ")", "validateFlood", "(", "row", ",", "col", "-", "1", ")", ";", "if", "(", "col", "<", "MAZE_WIDTH", "-", "1", ")", "validateFlood", "(", "row", ",", "col", "+", "1", ")", ";", "}" ]

[ "Routine", "Name", ":", "validateFlood", "File", ":", "mouse", ".", "c" ]

[ "//find all neighbors with lower values", "/*\n if((lower & UP) == UP && floodMaze[row - 1][col] == num - 1)\n return;\n if((lower & DOWN) == DOWN && floodMaze[row + 1][col] == num - 1)\n return;\n if((lower & LEFT) == LEFT && floodMaze[row][col - 1] == num - 1)\n return;\n if((lower & RIGHT) == RIGHT && floodMaze[row][col + 1] == num - 1)\n return;\n */", "//determine lowest flood value of neighbors", "//if value is valid, do nothing", "//otherwise, make value valid", "/*\n if(row > 0 && (mouseMaze[row][col] & UPPER_WALL) != UPPER_WALL)\n validateFlood(row - 1, col);\n if(row < MAZE_WIDTH - 1 && (mouseMaze[row][col] & LOWER_WALL) != LOWER_WALL)\n validateFlood(row + 1, col);\n if(col > 0 && (mouseMaze[row][col] & LEFT_WALL) != LEFT_WALL)\n validateFlood(row, col - 1);\n if(col < MAZE_WIDTH - 1 && (mouseMaze[row][col] & RIGHT_WALL) != RIGHT_WALL)\n validateFlood(row, col + 1);\n */" ]

[ { "param": "row", "type": "int" }, { "param": "col", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "floodFill", "File", ":", "mouse", ".", "c", "Full", "floodfill", "starting", "from", "specified", "location", "with", "flood", "num", ".", "Parameter", "Descriptions", ":", "name", "description", "num", "num", "to", "start", "flood", "at", "row", "row", "of", "tile", "to", "begin", "at", "col", "column", "of", "tile", "to", "begin", "at" ]

[ "void", "floodFill", "(", "int", "num", ",", "int", "row", ",", "int", "col", ")", "{", "floodMaze", "[", "row", "]", "[", "col", "]", "=", "num", ";", "if", "(", "row", ">", "0", "&&", "floodMaze", "[", "row", "-", "1", "]", "[", "col", "]", ">", "num", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "UPPER_WALL", ")", "==", "0", ")", "floodFill", "(", "num", "+", "1", ",", "row", "-", "1", ",", "col", ")", ";", "if", "(", "row", "<", "MAZE_WIDTH", "-", "1", "&&", "floodMaze", "[", "row", "+", "1", "]", "[", "col", "]", ">", "num", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "LOWER_WALL", ")", "==", "0", ")", "floodFill", "(", "num", "+", "1", ",", "row", "+", "1", ",", "col", ")", ";", "if", "(", "col", ">", "0", "&&", "floodMaze", "[", "row", "]", "[", "col", "-", "1", "]", ">", "num", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "LEFT_WALL", ")", "==", "0", ")", "floodFill", "(", "num", "+", "1", ",", "row", ",", "col", "-", "1", ")", ";", "if", "(", "col", "<", "MAZE_WIDTH", "-", "1", "&&", "floodMaze", "[", "row", "]", "[", "col", "+", "1", "]", ">", "num", "&&", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "RIGHT_WALL", ")", "==", "0", ")", "floodFill", "(", "num", "+", "1", ",", "row", ",", "col", "+", "1", ")", ";", "}" ]

[ "Routine", "Name", ":", "floodFill", "File", ":", "mouse", ".", "c" ]

[]

[ { "param": "num", "type": "int" }, { "param": "row", "type": "int" }, { "param": "col", "type": "int" } ]

[ "MIT" ]

[ "Boxes", "dead", "ends", "off", "to", "reduce", "computational", "intensity", "of", "flooding", "." ]

[ "void", "closeBoxes", "(", ")", "{", "int", "row", ",", "col", ";", "for", "(", "row", "=", "0", ";", "row", "<", "MAZE_WIDTH", ";", "row", "++", ")", "for", "(", "col", "=", "0", ";", "col", "<", "MAZE_WIDTH", ";", "col", "++", ")", "if", "(", "(", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "^", "WALLS", ")", "&", "(", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "^", "WALLS", ")", "-", "1", ")", ")", "==", "0", ")", "if", "(", "(", "row", "==", "curRow", "&&", "col", "==", "curCol", ")", "==", "0", ")", "{", "switch", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "^", "WALLS", ")", "{", "case", "LEFT_WALL", ":", "mouseMaze", "[", "row", "]", "[", "col", "]", "|=", "LEFT_WALL", ";", "mouseMaze", "[", "row", "]", "[", "col", "-", "1", "]", "|=", "RIGHT_WALL", ";", "break", ";", "case", "UPPER_WALL", ":", "mouseMaze", "[", "row", "]", "[", "col", "]", "|=", "UPPER_WALL", ";", "mouseMaze", "[", "row", "-", "1", "]", "[", "col", "]", "|=", "LOWER_WALL", ";", "break", ";", "case", "RIGHT_WALL", ":", "mouseMaze", "[", "row", "]", "[", "col", "]", "|=", "RIGHT_WALL", ";", "mouseMaze", "[", "row", "]", "[", "col", "+", "1", "]", "|=", "LEFT_WALL", ";", "break", ";", "case", "LOWER_WALL", ":", "mouseMaze", "[", "row", "]", "[", "col", "]", "|=", "LOWER_WALL", ";", "mouseMaze", "[", "row", "+", "1", "]", "[", "col", "]", "|=", "UPPER_WALL", ";", "break", ";", "}", "drawTileWalls", "(", "col", ",", "row", ",", "mouseMaze", "[", "row", "]", "[", "col", "]", ",", "YELLOW", ")", ";", "}", "}" ]

[ "TODO", "maybe", "integrate", "this", "into", "main", "algorithm", "Routine", "Name", ":", "closeBoxes", "File", ":", "mouse", ".", "c" ]

[ "//check if 1 bit is set to 0", "//mouseMaze[row][col] = WALLS;" ]

[]

[ "MIT" ]

[ "Routine", "Name", ":", "mouseMove", "File", ":", "mouse", ".", "c", "Moves", "mouse", "based", "on", "specified", "mode", ".", "Can", "also", "force", "mouse", "to", "jump", "to", "specific", "location", "in", "maze", ".", "Parameter", "Descriptions", ":", "name", "description", "mode", "if", "FLOOD", "use", "floodfill", "maze", "to", "move", "in", "best", "direction", ".", "if", "MANUAL", "jump", "to", "location", "row", "row", "of", "tile", "to", "jump", "to", "(", "MANUAL", "mode", "only", ")", "col", "column", "of", "tile", "to", "jump", "to", "(", "MANUAL", "mode", "only", ")" ]

[ "void", "mouseMove", "(", "int", "mode", ",", "int", "row", ",", "int", "col", ")", "{", "int", "lowest", ";", "int", "dir", ";", "if", "(", "mode", "==", "FLOOD", ")", "{", "dir", "=", "findLowerNeighbor", "(", "curRow", ",", "curCol", ")", ";", "if", "(", "(", "dir", "&", "LEFT", ")", "==", "LEFT", ")", "curCol", "--", ";", "else", "if", "(", "(", "dir", "&", "UP", ")", "==", "UP", ")", "curRow", "--", ";", "else", "if", "(", "(", "dir", "&", "RIGHT", ")", "==", "RIGHT", ")", "curCol", "++", ";", "else", "if", "(", "(", "dir", "&", "DOWN", ")", "==", "DOWN", ")", "curRow", "++", ";", "mvprintw", "(", "30", ",", "50", ",", "\"", "\"", ",", "dir", ")", ";", "}", "else", "if", "(", "mode", "==", "MANUAL", ")", "{", "curRow", "=", "row", ";", "curCol", "=", "col", ";", "}", "}" ]

[ "Routine", "Name", ":", "mouseMove", "File", ":", "mouse", ".", "c" ]

[]

[ { "param": "mode", "type": "int" }, { "param": "row", "type": "int" }, { "param": "col", "type": "int" } ]

[ "MIT" ]

[ "Routine", "Name", ":", "findLowerNeighbor", "File", ":", "mouse", ".", "c", "Find", "lowest", "neighbor", "'", "s", "direction", "if", "one", "exists", ".", "Can", "return", "multiple", "neighbors", "'", "directions", "if", "they", "tie", "for", "lowest", "Parameter", "Descriptions", ":", "name", "description", "row", "row", "of", "tile", "to", "check", "neighbors", "of", "col", "column", "of", "tile", "to", "check", "neighbors", "of" ]

[ "int", "findLowerNeighbor", "(", "int", "row", ",", "int", "col", ")", "{", "int", "lowest", ",", "result", ";", "result", "=", "0", ";", "lowest", "=", "floodMaze", "[", "row", "]", "[", "col", "]", ";", "if", "(", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "UPPER_WALL", ")", "!=", "UPPER_WALL", ")", "{", "if", "(", "floodMaze", "[", "row", "-", "1", "]", "[", "col", "]", "<", "lowest", ")", "{", "lowest", "=", "floodMaze", "[", "row", "-", "1", "]", "[", "col", "]", ";", "result", "=", "UP", ";", "}", "else", "if", "(", "floodMaze", "[", "row", "-", "1", "]", "[", "col", "]", "==", "lowest", ")", "result", "|=", "UP", ";", "}", "if", "(", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "LOWER_WALL", ")", "!=", "LOWER_WALL", ")", "{", "if", "(", "floodMaze", "[", "row", "+", "1", "]", "[", "col", "]", "<", "lowest", ")", "{", "lowest", "=", "floodMaze", "[", "row", "+", "1", "]", "[", "col", "]", ";", "result", "=", "DOWN", ";", "}", "else", "if", "(", "floodMaze", "[", "row", "+", "1", "]", "[", "col", "]", "==", "lowest", ")", "result", "|=", "DOWN", ";", "}", "if", "(", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "LEFT_WALL", ")", "!=", "LEFT_WALL", ")", "{", "if", "(", "floodMaze", "[", "row", "]", "[", "col", "-", "1", "]", "<", "lowest", ")", "{", "lowest", "=", "floodMaze", "[", "row", "]", "[", "col", "-", "1", "]", ";", "result", "=", "LEFT", ";", "}", "else", "if", "(", "floodMaze", "[", "row", "]", "[", "col", "-", "1", "]", "==", "lowest", ")", "result", "|=", "LEFT", ";", "}", "if", "(", "(", "mouseMaze", "[", "row", "]", "[", "col", "]", "&", "RIGHT_WALL", ")", "!=", "RIGHT_WALL", ")", "{", "if", "(", "floodMaze", "[", "row", "]", "[", "col", "+", "1", "]", "<", "lowest", ")", "{", "lowest", "=", "floodMaze", "[", "row", "]", "[", "col", "+", "1", "]", ";", "result", "=", "RIGHT", ";", "}", "else", "if", "(", "floodMaze", "[", "row", "]", "[", "col", "+", "1", "]", "==", "lowest", ")", "result", "|=", "RIGHT", ";", "}", "return", "result", ";", "}" ]

[ "Routine", "Name", ":", "findLowerNeighbor", "File", ":", "mouse", ".", "c" ]

[ "/* \n * lowest - smallest found flood\n * result - lowest directions\n */", "//lowest = MAZE_WIDTH * MAZE_WIDTH - 1;", "/* 1. Check if adjacent tile is neighbor (accessible by mouse)\n * 2. If neighboring, see if flood value is lower or equal to current lowest\n * 3. Update lowest and lowest tile bits accordingly\n */", "//Check upper neighbor", "//Check lower neighbor", "//Check left neighbor", "//Check right neighbor" ]

[ { "param": "row", "type": "int" }, { "param": "col", "type": "int" } ]

[ "Python-2.0" ]

[ "Process", "an", "edge", "linking", "two", "linked", "vertices", "Note", ":", "global", "variable", "v", "set", "to", "the", "base", "of", "one", "end", "of", "the", "linking", "edge" ]

[ "void", "PAIR", "(", "int", "*", "outcome", ")", "{", "int", "u", ",", "w", ",", "temp", ";", "#ifdef", "DEBUG", "printf", "(", "\"", "\\n", "\"", ",", "v", ")", ";", "#endif", "e", "=", "NEXTEDGE", "[", "v", "]", ";", "while", "(", "SLACK", "(", "e", ")", "!=", "2", "*", "DELTA", ")", "e", "=", "NEXTPAIR", "[", "e", "]", ";", "w", "=", "BEND", "(", "e", ")", ";", "LINK", "[", "BMATE", "(", "w", ")", "]", "=", "-", "e", ";", "u", "=", "BMATE", "(", "v", ")", ";", "while", "(", "LINK", "[", "u", "]", "!=", "-", "e", ")", "{", "LINK", "[", "u", "]", "=", "-", "e", ";", "if", "(", "MATE", "[", "w", "]", "!=", "DUMMYEDGE", ")", "{", "temp", "=", "v", ";", "v", "=", "w", ";", "w", "=", "temp", ";", "}", "v", "=", "BLINK", "(", "v", ")", ";", "u", "=", "BMATE", "(", "v", ")", ";", "}", "if", "(", "u", "==", "DUMMYVERTEX", "&&", "v", "!=", "w", ")", "{", "*", "outcome", "=", "1", ";", "return", ";", "}", "newlast", "=", "v", ";", "newbase", "=", "v", ";", "oldfirst", "=", "NEXTVTX", "[", "v", "]", ";", "LINK_PATH", "(", "e", ")", ";", "LINK_PATH", "(", "OPPEDGE", "(", "e", ")", ")", ";", "NEXTVTX", "[", "newlast", "]", "=", "oldfirst", ";", "if", "(", "LASTVTX", "[", "newbase", "]", "==", "newbase", ")", "LASTVTX", "[", "newbase", "]", "=", "newlast", ";", "NEXTPAIR", "[", "DUMMYEDGE", "]", "=", "DUMMYEDGE", ";", "MERGE_PAIRS", "(", "newbase", ")", ";", "i", "=", "NEXTVTX", "[", "newbase", "]", ";", "do", "{", "MERGE_PAIRS", "(", "i", ")", ";", "i", "=", "NEXTVTX", "[", "LASTVTX", "[", "i", "]", "]", ";", "SCAN", "(", "i", ",", "2", "*", "DELTA", "-", "SLACK", "(", "MATE", "[", "i", "]", ")", ")", ";", "i", "=", "NEXTVTX", "[", "LASTVTX", "[", "i", "]", "]", ";", "}", "while", "(", "i", "!=", "oldfirst", ")", ";", "*", "outcome", "=", "0", ";", "return", ";", "}" ]

[ "Process", "an", "edge", "linking", "two", "linked", "vertices", "Note", ":", "global", "variable", "v", "set", "to", "the", "base", "of", "one", "end", "of", "the", "linking", "edge" ]

[]

[ { "param": "outcome", "type": "int" } ]

[ "Python-2.0" ]

[ "merges", "a", "subblossom", "'", "s", "pair", "vector", "into", "a", "new", "blossom", "'", "s", "pair", "vector", "v", "is", "the", "base", "of", "the", "previously", "unlinked", "subblossom", "Note", ":", "global", "variable", "newbase", "set", "to", "the", "base", "of", "the", "new", "blossom", "called", "with", "NEXTPAIR", "[", "DUMMYEDGE", "]", "pointing", "to", "the", "first", "edge", "on", "newbase", "'", "s", "pair", "vector" ]

[ "void", "MERGE_PAIRS", "(", "int", "v", ")", "{", "#ifdef", "DEBUG", "printf", "(", "\"", "\\n", "\"", ",", "v", ")", ";", "#endif", "NEXT_D", "[", "v", "]", "=", "LAST_D", ";", "pairpoint", "=", "DUMMYEDGE", ";", "f", "=", "NEXTEDGE", "[", "v", "]", ";", "while", "(", "f", "!=", "DUMMYEDGE", ")", "{", "e", "=", "f", ";", "neighbor", "=", "END", "[", "e", "]", ";", "f", "=", "NEXTPAIR", "[", "f", "]", ";", "if", "(", "BASE", "[", "neighbor", "]", "!=", "newbase", ")", "INSERT_PAIR", "(", ")", ";", "}", "}" ]

[ "merges", "a", "subblossom", "'", "s", "pair", "vector", "into", "a", "new", "blossom", "'", "s", "pair", "vector", "v", "is", "the", "base", "of", "the", "previously", "unlinked", "subblossom", "Note", ":", "global", "variable", "newbase", "set", "to", "the", "base", "of", "the", "new", "blossom", "called", "with", "NEXTPAIR", "[", "DUMMYEDGE", "]", "pointing", "to", "the", "first", "edge", "on", "newbase", "'", "s", "pair", "vector" ]

[]

[ { "param": "v", "type": "int" } ]

[ "Python-2.0" ]

[ "links", "the", "unlinked", "vertices", "in", "the", "path", "P", "(", "END", "[", "e", "]", "newbase", ")", "Note", ":", "global", "variable", "newbase", "is", "set", "to", "the", "base", "vertex", "of", "the", "new", "blossom", "newlast", "is", "set", "to", "the", "last", "vertex", "in", "newbase", "'", "s", "current", "blossom" ]

[ "void", "LINK_PATH", "(", "int", "e", ")", "{", "int", "u", ";", "#ifdef", "DEBUG", "printf", "(", "\"", "\\n", "\"", ",", "END", "[", "OPPEDGE", "(", "e", ")", "]", ",", "END", "[", "e", "]", ")", ";", "#endif", "v", "=", "BEND", "(", "e", ")", ";", "while", "(", "v", "!=", "newbase", ")", "{", "u", "=", "BMATE", "(", "v", ")", ";", "LINK", "[", "u", "]", "=", "OPPEDGE", "(", "e", ")", ";", "NEXTVTX", "[", "newlast", "]", "=", "v", ";", "NEXTVTX", "[", "LASTVTX", "[", "v", "]", "]", "=", "u", ";", "newlast", "=", "LASTVTX", "[", "u", "]", ";", "i", "=", "v", ";", "BASE", "[", "i", "]", "=", "newbase", ";", "i", "=", "NEXTVTX", "[", "i", "]", ";", "while", "(", "i", "!=", "DUMMYVERTEX", ")", "{", "BASE", "[", "i", "]", "=", "newbase", ";", "i", "=", "NEXTVTX", "[", "i", "]", ";", "}", "e", "=", "LINK", "[", "v", "]", ";", "v", "=", "BEND", "(", "e", ")", ";", "}", "}" ]

[ "links", "the", "unlinked", "vertices", "in", "the", "path", "P", "(", "END", "[", "e", "]", "newbase", ")", "Note", ":", "global", "variable", "newbase", "is", "set", "to", "the", "base", "vertex", "of", "the", "new", "blossom", "newlast", "is", "set", "to", "the", "last", "vertex", "in", "newbase", "'", "s", "current", "blossom" ]

[]

[ { "param": "e", "type": "int" } ]

[ "Python-2.0" ]

[ "Update", "a", "blossom", "'", "s", "pair", "vector", ".", "Note", ":", "called", "with", "global", "variable", "e", "set", "to", "the", "edge", "to", "be", "inserted", ".", "neighbor", "set", "to", "the", "vertex", "at", "the", "end", "of", "e", "pairpoint", "set", "to", "the", "next", "pair", "on", "the", "pair", "vector" ]

[ "void", "INSERT_PAIR", "(", "void", ")", "{", "int", "del_e", ";", "#ifdef", "DEBUG", "printf", "(", "\"", "\\n", "\"", ",", "END", "[", "OPPEDGE", "(", "e", ")", "]", ",", "END", "[", "e", "]", ")", ";", "#endif", "del_e", "=", "SLACK", "(", "e", ")", "/", "2", ";", "nextpoint", "=", "NEXTPAIR", "[", "pairpoint", "]", ";", "while", "(", "END", "[", "nextpoint", "]", "<", "neighbor", ")", "{", "pairpoint", "=", "nextpoint", ";", "nextpoint", "=", "NEXTPAIR", "[", "nextpoint", "]", ";", "}", "if", "(", "END", "[", "nextpoint", "]", "==", "neighbor", ")", "{", "if", "(", "del_e", ">=", "SLACK", "(", "nextpoint", ")", "/", "2", ")", "return", ";", "nextpoint", "=", "NEXTPAIR", "[", "nextpoint", "]", ";", "}", "NEXTPAIR", "[", "pairpoint", "]", "=", "e", ";", "pairpoint", "=", "e", ";", "NEXTPAIR", "[", "e", "]", "=", "nextpoint", ";", "if", "(", "NEXT_D", "[", "newbase", "]", ">", "del_e", ")", "NEXT_D", "[", "newbase", "]", "=", "del_e", ";", "}" ]

[ "Update", "a", "blossom", "'", "s", "pair", "vector", "." ]

[]

[]

[ "Python-2.0" ]

[ "Number", "of", "straight", "connecting", "lines", "of", "which", "each", "polynomial", "consists", ".", "So", "between", "one", "data", "point", "and", "the", "next", "(", "nb", "-", "1", ")", "points", "are", "placed", "." ]

[ "void", "g2_c_raspln", "(", "int", "n", ",", "const", "double", "*", "points", ",", "double", "tn", ",", "double", "*", "sxy", ")", "{", "int", "i", ",", "j", ";", "double", "bias", ",", "tnFactor", ",", "tangentL1", ",", "tangentL2", ";", "double", "D1x", ",", "D1y", ",", "D2x", ",", "D2y", ",", "t1x", ",", "t1y", ",", "t2x", ",", "t2y", ";", "double", "h1", "[", "nb", "+", "1", "]", ";", "double", "h2", "[", "nb", "+", "1", "]", ";", "double", "h3", "[", "nb", "+", "1", "]", ";", "double", "h4", "[", "nb", "+", "1", "]", ";", "double", "*", "const", "x", "=", "(", "double", "*", ")", "g2_malloc", "(", "n", "*", "2", "*", "sizeof", "(", "double", ")", ")", ";", "double", "*", "const", "y", "=", "x", "+", "n", ";", "g2_split", "(", "n", ",", "points", ",", "x", ",", "y", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb", "+", "1", ";", "i", "++", ")", "{", "double", "t", ",", "tt", ",", "ttt", ";", "t", "=", "(", "double", ")", "i", "/", "nb", ";", "tt", "=", "t", "*", "t", ";", "ttt", "=", "t", "*", "tt", ";", "h1", "[", "i", "]", "=", "2.", "*", "ttt", "-", "3.", "*", "tt", "+", "1.", ";", "h2", "[", "i", "]", "=", "-2.", "*", "ttt", "+", "3.", "*", "tt", ";", "h3", "[", "i", "]", "=", "ttt", "-", "2.", "*", "tt", "+", "t", ";", "h4", "[", "i", "]", "=", "ttt", "-", "tt", ";", "}", "if", "(", "tn", "<=", "0.", ")", "{", "tnFactor", "=", "2.", ";", "fputs", "(", "\"", "\"", ",", "stderr", ")", ";", "}", "else", "if", "(", "tn", ">=", "2.", ")", "{", "tnFactor", "=", "0.", ";", "fputs", "(", "\"", "\"", ",", "stderr", ")", ";", "}", "else", "tnFactor", "=", "2.", "-", "tn", ";", "D1x", "=", "D1y", "=", "0.", ";", "for", "(", "j", "=", "0", ";", "j", "<", "n", "-", "2", ";", "j", "++", ")", "{", "t1x", "=", "x", "[", "j", "+", "1", "]", "-", "x", "[", "j", "]", ";", "t1y", "=", "y", "[", "j", "+", "1", "]", "-", "y", "[", "j", "]", ";", "t2x", "=", "x", "[", "j", "+", "2", "]", "-", "x", "[", "j", "+", "1", "]", ";", "t2y", "=", "y", "[", "j", "+", "2", "]", "-", "y", "[", "j", "+", "1", "]", ";", "tangentL1", "=", "t1x", "*", "t1x", "+", "t1y", "*", "t1y", ";", "tangentL2", "=", "t2x", "*", "t2x", "+", "t2y", "*", "t2y", ";", "if", "(", "tangentL1", "+", "tangentL2", "==", "0", ")", "bias", "=", ".5", ";", "else", "bias", "=", "tangentL2", "/", "(", "tangentL1", "+", "tangentL2", ")", ";", "D2x", "=", "tnFactor", "*", "(", "bias", "*", "t1x", "+", "(", "1", "-", "bias", ")", "*", "t2x", ")", ";", "D2y", "=", "tnFactor", "*", "(", "bias", "*", "t1y", "+", "(", "1", "-", "bias", ")", "*", "t2y", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb", ";", "i", "++", ")", "{", "sxy", "[", "2", "*", "nb", "*", "j", "+", "i", "+", "i", "]", "=", "h1", "[", "i", "]", "*", "x", "[", "j", "]", "+", "h2", "[", "i", "]", "*", "x", "[", "j", "+", "1", "]", "+", "h3", "[", "i", "]", "*", "D1x", "+", "h4", "[", "i", "]", "*", "D2x", ";", "sxy", "[", "2", "*", "nb", "*", "j", "+", "i", "+", "i", "+", "1", "]", "=", "h1", "[", "i", "]", "*", "y", "[", "j", "]", "+", "h2", "[", "i", "]", "*", "y", "[", "j", "+", "1", "]", "+", "h3", "[", "i", "]", "*", "D1y", "+", "h4", "[", "i", "]", "*", "D2y", ";", "}", "D1x", "=", "D2x", ";", "D1y", "=", "D2y", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nb", "+", "1", ";", "i", "++", ")", "{", "sxy", "[", "2", "*", "nb", "*", "(", "n", "-", "2", ")", "+", "i", "+", "i", "]", "=", "h1", "[", "i", "]", "*", "x", "[", "n", "-", "2", "]", "+", "h2", "[", "i", "]", "*", "x", "[", "n", "-", "1", "]", "+", "h3", "[", "i", "]", "*", "D1x", ";", "sxy", "[", "2", "*", "nb", "*", "(", "n", "-", "2", ")", "+", "i", "+", "i", "+", "1", "]", "=", "h1", "[", "i", "]", "*", "y", "[", "n", "-", "2", "]", "+", "h2", "[", "i", "]", "*", "y", "[", "n", "-", "1", "]", "+", "h3", "[", "i", "]", "*", "D1y", ";", "}", "g2_free", "(", "x", ")", ";", "}" ]

[ "Number", "of", "straight", "connecting", "lines", "of", "which", "each", "polynomial", "consists", "." ]

[ "/* Values of the Hermite basis functions */", "/* at nb+1 evenly spaced points in [0,1] */", "/*\n * First, store the values of the Hermite basis functions in a table h[ ]\n * so no time is wasted recalculating them\n */", "/*\n * Set local tnFactor based on input parameter tn\n */", "/* first point has no preceding point */", "/* store as preceding point in */", "/* the next pass */", "/*\n * Do the last subinterval as a special case since no point follows the\n * last point\n */" ]

[ { "param": "n", "type": "int" }, { "param": "points", "type": "double" }, { "param": "tn", "type": "double" }, { "param": "sxy", "type": "double" } ]

[ "Python-2.0" ]

[ "Plot", "a", "piecewise", "cubic", "polynomial", "with", "adjustable", "roundness", "through", "the", "given", "data", "points", ".", "Each", "Hermite", "polynomial", "between", "two", "data", "points", "is", "made", "up", "of", "40", "lines", ".", "Tension", "factor", "\\", "a", "tn", "must", "be", "between", "0", ".", "0", "(", "very", "rounded", ")", "and", "2", ".", "0", "(", "not", "rounded", "at", "all", "i", ".", "e", ".", "essentially", "a", "\\", "ref", "g2_poly_line", "\"", "polyline", "\"", ")", ".", "\\", "ingroup", "splines" ]

[ "void", "g2_raspln", "(", "int", "dev", ",", "int", "n", ",", "double", "*", "points", ",", "double", "tn", ")", "{", "const", "int", "m", "=", "(", "n", "-", "1", ")", "*", "nb", "+", "1", ";", "double", "*", "const", "sxy", "=", "(", "double", "*", ")", "g2_malloc", "(", "m", "*", "2", "*", "sizeof", "(", "double", ")", ")", ";", "g2_c_raspln", "(", "n", ",", "points", ",", "tn", ",", "sxy", ")", ";", "g2_poly_line", "(", "dev", ",", "m", ",", "sxy", ")", ";", "g2_free", "(", "sxy", ")", ";", "}" ]

[ "Plot", "a", "piecewise", "cubic", "polynomial", "with", "adjustable", "roundness", "through", "the", "given", "data", "points", "." ]

[ "/* coords of the entire spline curve */" ]

[ { "param": "dev", "type": "int" }, { "param": "n", "type": "int" }, { "param": "points", "type": "double" }, { "param": "tn", "type": "double" } ]

[ "Python-2.0" ]

[ "Plot", "a", "filled", "piecewise", "cubic", "polynomial", "with", "adjustable", "roundness", "through", "the", "given", "data", "points", ".", "Each", "Hermite", "polynomial", "between", "two", "data", "points", "is", "made", "up", "of", "40", "lines", ".", "Tension", "factor", "\\", "a", "tn", "must", "be", "between", "0", ".", "0", "(", "very", "rounded", ")", "and", "2", ".", "0", "(", "not", "rounded", "at", "all", "i", ".", "e", ".", "essentially", "a", "\\", "ref", "g2_poly_line", "\"", "polyline", "\"", ")", ".", "\\", "ingroup", "splines" ]

[ "void", "g2_filled_raspln", "(", "int", "dev", ",", "int", "n", ",", "double", "*", "points", ",", "double", "tn", ")", "{", "const", "int", "m", "=", "(", "n", "-", "1", ")", "*", "nb", "+", "2", ";", "double", "*", "const", "sxy", "=", "(", "double", "*", ")", "g2_malloc", "(", "m", "*", "2", "*", "sizeof", "(", "double", ")", ")", ";", "g2_c_raspln", "(", "n", ",", "points", ",", "tn", ",", "sxy", ")", ";", "sxy", "[", "m", "+", "m", "-", "2", "]", "=", "points", "[", "n", "+", "n", "-", "2", "]", ";", "sxy", "[", "m", "+", "m", "-", "1", "]", "=", "points", "[", "1", "]", ";", "g2_filled_polygon", "(", "dev", ",", "m", ",", "sxy", ")", ";", "g2_free", "(", "sxy", ")", ";", "}" ]

[ "Plot", "a", "filled", "piecewise", "cubic", "polynomial", "with", "adjustable", "roundness", "through", "the", "given", "data", "points", "." ]

[ "/* coords of the entire spline curve */" ]

[ { "param": "dev", "type": "int" }, { "param": "n", "type": "int" }, { "param": "points", "type": "double" }, { "param": "tn", "type": "double" } ]

[ "Python-2.0" ]

[ "#undef", "nb", "#define", "nb", "40", "Number", "of", "straight", "connecting", "lines", "of", "which", "each", "polynomial", "consists", ".", "So", "between", "one", "data", "point", "and", "the", "next", "(", "nb", "-", "1", ")", "points", "are", "placed", "." ]

[ "void", "g2_c_para_3", "(", "int", "n", ",", "const", "double", "*", "points", ",", "int", "m", ",", "double", "*", "sxy", ")", "{", "#define", "dgr", "\t(3+1)", "\n", "#define", "nb2", "\t(nb*2)", "\n", "int", "i", ",", "j", ";", "double", "x1t", ",", "y1t", ";", "double", "o", ",", "step", ";", "double", "X", "[", "nb2", "]", ";", "double", "Y", "[", "nb2", "]", ";", "double", "t", "[", "dgr", "]", ";", "double", "Xpts", "[", "dgr", "]", ";", "double", "Ypts", "[", "dgr", "]", ";", "double", "s", "[", "nb2", "]", ";", "m", "=", "m", ";", "g2_split", "(", "dgr", ",", "points", ",", "Xpts", ",", "Ypts", ")", ";", "t", "[", "0", "]", "=", "0.", ";", "for", "(", "i", "=", "1", ";", "i", "<", "dgr", ";", "i", "++", ")", "{", "x1t", "=", "Xpts", "[", "i", "]", "-", "Xpts", "[", "i", "-", "1", "]", ";", "y1t", "=", "Ypts", "[", "i", "]", "-", "Ypts", "[", "i", "-", "1", "]", ";", "t", "[", "i", "]", "=", "t", "[", "i", "-", "1", "]", "+", "sqrt", "(", "x1t", "*", "x1t", "+", "y1t", "*", "y1t", ")", ";", "}", "step", "=", "t", "[", "2", "]", "/", "nb2", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb2", ";", "i", "++", ")", "s", "[", "i", "]", "=", "i", "*", "step", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Xpts", ",", "nb2", ",", "s", ",", "X", ")", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Ypts", ",", "nb2", ",", "s", ",", "Y", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb2", ";", "i", "++", ")", "{", "sxy", "[", "i", "+", "i", "]", "=", "X", "[", "i", "]", ";", "sxy", "[", "i", "+", "i", "+", "1", "]", "=", "Y", "[", "i", "]", ";", "}", "for", "(", "j", "=", "1", ";", "j", "<", "n", "-", "dgr", "+", "1", ";", "j", "++", ")", "{", "g2_split", "(", "dgr", ",", "points", "+", "j", "+", "j", ",", "Xpts", ",", "Ypts", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "dgr", ";", "i", "++", ")", "{", "x1t", "=", "Xpts", "[", "i", "]", "-", "Xpts", "[", "i", "-", "1", "]", ";", "y1t", "=", "Ypts", "[", "i", "]", "-", "Ypts", "[", "i", "-", "1", "]", ";", "t", "[", "i", "]", "=", "t", "[", "i", "-", "1", "]", "+", "sqrt", "(", "x1t", "*", "x1t", "+", "y1t", "*", "y1t", ")", ";", "}", "o", "=", "t", "[", "1", "]", ";", "step", "=", "(", "t", "[", "2", "]", "-", "o", ")", "/", "nb", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb", ";", "i", "++", ")", "s", "[", "i", "]", "=", "i", "*", "step", "+", "o", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Xpts", ",", "nb", ",", "s", ",", "X", ")", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Ypts", ",", "nb", ",", "s", ",", "Y", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb", ";", "i", "++", ")", "{", "sxy", "[", "(", "j", "+", "1", ")", "*", "nb2", "+", "i", "+", "i", "]", "=", "X", "[", "i", "]", ";", "sxy", "[", "(", "j", "+", "1", ")", "*", "nb2", "+", "i", "+", "i", "+", "1", "]", "=", "Y", "[", "i", "]", ";", "}", "}", "o", "=", "t", "[", "2", "]", ";", "step", "=", "(", "t", "[", "3", "]", "-", "o", ")", "/", "nb", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb", ";", "i", "++", ")", "s", "[", "i", "]", "=", "i", "*", "step", "+", "o", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Xpts", ",", "nb", ",", "s", ",", "X", ")", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Ypts", ",", "nb", ",", "s", ",", "Y", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb", ";", "i", "++", ")", "{", "sxy", "[", "(", "n", "-", "dgr", "+", "2", ")", "*", "nb2", "+", "i", "+", "i", "]", "=", "X", "[", "i", "]", ";", "sxy", "[", "(", "n", "-", "dgr", "+", "2", ")", "*", "nb2", "+", "i", "+", "i", "+", "1", "]", "=", "Y", "[", "i", "]", ";", "}", "sxy", "[", "(", "n", "-", "1", ")", "*", "nb2", "]", "=", "points", "[", "n", "+", "n", "-", "2", "]", ";", "sxy", "[", "(", "n", "-", "1", ")", "*", "nb2", "+", "1", "]", "=", "points", "[", "n", "+", "n", "-", "1", "]", ";", "}" ]

[ "#undef", "nb", "#define", "nb", "40", "Number", "of", "straight", "connecting", "lines", "of", "which", "each", "polynomial", "consists", "." ]

[ "/* x-coords of the current curve piece */", "/* y-coords of the current curve piece */", "/* data point parameter values */", "/* x-coords data point subsection */", "/* y-coords data point subsection */", "/* parameter values at which to interpolate */", "/* dummy argument; stop compiler complaints */", "/* Do first TWO subintervals first */", "/* Next, do later central subintervals */", "/* look up once */", "/* Now do last subinterval */" ]

[ { "param": "n", "type": "int" }, { "param": "points", "type": "double" }, { "param": "m", "type": "int" }, { "param": "sxy", "type": "double" } ]

[ "Python-2.0" ]

[ "Number", "of", "straight", "connecting", "lines", "of", "which", "each", "polynomial", "consists", ".", "So", "between", "one", "data", "point", "and", "the", "next", "(", "nb", "-", "1", ")", "points", "are", "placed", "." ]

[ "void", "g2_c_para_5", "(", "int", "n", ",", "const", "double", "*", "points", ",", "int", "m", ",", "double", "*", "sxy", ")", "{", "#undef", "\tdgr", "\n", "#define", "dgr", "\t(5+1)", "\n", "#define", "nb3", "\t(nb*3)", "\n", "int", "i", ",", "j", ";", "double", "x1t", ",", "y1t", ";", "double", "o", ",", "step", ";", "double", "X", "[", "nb3", "]", ";", "double", "Y", "[", "nb3", "]", ";", "double", "t", "[", "dgr", "]", ";", "double", "Xpts", "[", "dgr", "]", ";", "double", "Ypts", "[", "dgr", "]", ";", "double", "s", "[", "nb3", "]", ";", "m", "=", "m", ";", "g2_split", "(", "dgr", ",", "points", ",", "Xpts", ",", "Ypts", ")", ";", "t", "[", "0", "]", "=", "0.", ";", "for", "(", "i", "=", "1", ";", "i", "<", "dgr", ";", "i", "++", ")", "{", "x1t", "=", "Xpts", "[", "i", "]", "-", "Xpts", "[", "i", "-", "1", "]", ";", "y1t", "=", "Ypts", "[", "i", "]", "-", "Ypts", "[", "i", "-", "1", "]", ";", "t", "[", "i", "]", "=", "t", "[", "i", "-", "1", "]", "+", "sqrt", "(", "x1t", "*", "x1t", "+", "y1t", "*", "y1t", ")", ";", "}", "step", "=", "t", "[", "3", "]", "/", "nb3", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb3", ";", "i", "++", ")", "s", "[", "i", "]", "=", "i", "*", "step", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Xpts", ",", "nb3", ",", "s", ",", "X", ")", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Ypts", ",", "nb3", ",", "s", ",", "Y", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb3", ";", "i", "++", ")", "{", "sxy", "[", "i", "+", "i", "]", "=", "X", "[", "i", "]", ";", "sxy", "[", "i", "+", "i", "+", "1", "]", "=", "Y", "[", "i", "]", ";", "}", "for", "(", "j", "=", "1", ";", "j", "<", "n", "-", "dgr", "+", "1", ";", "j", "++", ")", "{", "g2_split", "(", "dgr", ",", "points", "+", "j", "+", "j", ",", "Xpts", ",", "Ypts", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "dgr", ";", "i", "++", ")", "{", "x1t", "=", "Xpts", "[", "i", "]", "-", "Xpts", "[", "i", "-", "1", "]", ";", "y1t", "=", "Ypts", "[", "i", "]", "-", "Ypts", "[", "i", "-", "1", "]", ";", "t", "[", "i", "]", "=", "t", "[", "i", "-", "1", "]", "+", "sqrt", "(", "x1t", "*", "x1t", "+", "y1t", "*", "y1t", ")", ";", "}", "o", "=", "t", "[", "2", "]", ";", "step", "=", "(", "t", "[", "3", "]", "-", "o", ")", "/", "nb", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb", ";", "i", "++", ")", "s", "[", "i", "]", "=", "i", "*", "step", "+", "o", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Xpts", ",", "nb", ",", "s", ",", "X", ")", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Ypts", ",", "nb", ",", "s", ",", "Y", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb", ";", "i", "++", ")", "{", "sxy", "[", "(", "j", "+", "2", ")", "*", "nb2", "+", "i", "+", "i", "]", "=", "X", "[", "i", "]", ";", "sxy", "[", "(", "j", "+", "2", ")", "*", "nb2", "+", "i", "+", "i", "+", "1", "]", "=", "Y", "[", "i", "]", ";", "}", "}", "o", "=", "t", "[", "3", "]", ";", "step", "=", "(", "t", "[", "5", "]", "-", "o", ")", "/", "nb2", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb2", ";", "i", "++", ")", "s", "[", "i", "]", "=", "i", "*", "step", "+", "o", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Xpts", ",", "nb2", ",", "s", ",", "X", ")", ";", "g2_c_newton", "(", "dgr", ",", "t", ",", "Ypts", ",", "nb2", ",", "s", ",", "Y", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nb2", ";", "i", "++", ")", "{", "sxy", "[", "(", "n", "-", "dgr", "+", "3", ")", "*", "nb2", "+", "i", "+", "i", "]", "=", "X", "[", "i", "]", ";", "sxy", "[", "(", "n", "-", "dgr", "+", "3", ")", "*", "nb2", "+", "i", "+", "i", "+", "1", "]", "=", "Y", "[", "i", "]", ";", "}", "sxy", "[", "(", "n", "-", "1", ")", "*", "nb2", "]", "=", "points", "[", "n", "+", "n", "-", "2", "]", ";", "sxy", "[", "(", "n", "-", "1", ")", "*", "nb2", "+", "1", "]", "=", "points", "[", "n", "+", "n", "-", "1", "]", ";", "}" ]

[ "Number", "of", "straight", "connecting", "lines", "of", "which", "each", "polynomial", "consists", "." ]

[ "/* x-coords of the current curve piece */", "/* y-coords of the current curve piece */", "/* data point parameter values */", "/* x-coords data point subsection */", "/* y-coords data point subsection */", "/* parameter values at which to interpolate */", "/* dummy argument; stop compiler complaints */", "/* Do first THREE subintervals first */", "/* Next, do later central subintervals */", "/* look up once */", "/* Now do last TWO subinterval */" ]

[ { "param": "n", "type": "int" }, { "param": "points", "type": "double" }, { "param": "m", "type": "int" }, { "param": "sxy", "type": "double" } ]

[ "Python-2.0" ]

[ "1", "if", "device", "exist", "otherwise", "0" ]

[ "int", "g2_device_exist", "(", "int", "dix", ")", "{", "if", "(", "dix", "<", "0", "||", "dix", ">=", "g2_dev_size", "||", "g2_dev", "[", "dix", "]", ".", "t", "==", "g2_ILLEGAL", "||", "g2_dev", "[", "dix", "]", ".", "t", "==", "g2_NDEV", ")", "return", "0", ";", "return", "1", ";", "}" ]

[ "1", "if", "device", "exist", "otherwise", "0" ]

[]

[ { "param": "dix", "type": "int" } ]

[ "Python-2.0" ]

[ "get", "free", "place", "for", "new", "device" ]

[ "int", "g2_get_free_device", "(", ")", "{", "int", "i", ",", "dix", ";", "if", "(", "g2_dev", "==", "NULL", ")", "{", "g2_dev_size", "=", "1", ";", "g2_dev", "=", "g2_malloc", "(", "sizeof", "(", "g2_device", ")", ")", ";", "g2_dev", "[", "0", "]", ".", "t", "=", "g2_NDEV", ";", "g2_dev", "[", "0", "]", ".", "d", ".", "pd", "=", "NULL", ";", "}", "dix", "=", "-1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "g2_dev_size", ";", "i", "++", ")", "if", "(", "g2_dev", "[", "i", "]", ".", "t", "==", "g2_NDEV", ")", "{", "dix", "=", "i", ";", "break", ";", "}", "if", "(", "dix", "<", "0", ")", "{", "dix", "=", "g2_dev_size", "++", ";", "g2_dev", "=", "g2_realloc", "(", "g2_dev", ",", "g2_dev_size", "*", "sizeof", "(", "g2_device", ")", ")", ";", "g2_dev", "[", "dix", "]", ".", "t", "=", "g2_NDEV", ";", "g2_dev", "[", "dix", "]", ".", "d", ".", "pd", "=", "NULL", ";", "}", "return", "dix", ";", "}" ]

[ "get", "free", "place", "for", "new", "device" ]

[ "/* if NULL initialize */", "/* set to free */", "/* no device yet */", "/* find empty place */", "/* no place for device */", "/* set to free */", "/* no device yet */" ]

[]

[ "Python-2.0" ]

[ "Move", "graphic", "cursor", "relative", "to", "the", "currner", "graphical", "cursor", "position", ".", "\\", "param", "dev", "device", "\\", "param", "dx", "x", "coordinate", "increment", "\\", "param", "dy", "y", "coordinate", "increment", "\\", "ingroup", "graphic" ]

[ "void", "g2_move_r", "(", "int", "dev", ",", "double", "dx", ",", "double", "dy", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "devp", "->", "x", "+=", "dx", ";", "devp", "->", "y", "+=", "dy", ";", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "g2_move_r", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "dx", ",", "dy", ")", ";", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Move", "graphic", "cursor", "relative", "to", "the", "currner", "graphical", "cursor", "position", "." ]

[ "/* set graph. cursor */" ]

[ { "param": "dev", "type": "int" }, { "param": "dx", "type": "double" }, { "param": "dy", "type": "double" } ]

[ "Python-2.0" ]

[ "Plot", "a", "point", "relative", "to", "graphical", "cursor", ".", "\\", "param", "dev", "device", "\\", "param", "rx", "relative", "x", "coordinate", "\\", "param", "ry", "relative", "y", "coordinate", "\\", "ingroup", "graphic" ]

[ "void", "g2_plot_r", "(", "int", "dev", ",", "double", "rx", ",", "double", "ry", ")", "{", "g2_device", "*", "devp", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "g2_plot", "(", "dev", ",", "devp", "->", "x", "+", "rx", ",", "devp", "->", "y", "+", "ry", ")", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Plot", "a", "point", "relative", "to", "graphical", "cursor", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "rx", "type": "double" }, { "param": "ry", "type": "double" } ]

[ "Python-2.0" ]

[ "Draw", "line", "relative", "to", "the", "graphic", "cursor", ".", "\\", "param", "dev", "device", "\\", "param", "dx", "relative", "x", "coordinate", "\\", "param", "dy", "relative", "y", "coordinate", "\\", "ingroup", "graphic" ]

[ "void", "g2_line_r", "(", "int", "dev", ",", "double", "dx", ",", "double", "dy", ")", "{", "g2_device", "*", "devp", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "g2_line", "(", "dev", ",", "devp", "->", "x", ",", "devp", "->", "y", ",", "devp", "->", "x", "+", "dx", ",", "devp", "->", "y", "+", "dy", ")", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Draw", "line", "relative", "to", "the", "graphic", "cursor", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "dx", "type": "double" }, { "param": "dy", "type": "double" } ]

[ "Python-2.0" ]

[ "Draw", "a", "triangle", "described", "by", "3", "corner", "points", ".", "\\", "ingroup", "graphic" ]

[ "void", "g2_triangle", "(", "int", "dev", ",", "double", "x1", ",", "double", "y1", ",", "double", "x2", ",", "double", "y2", ",", "double", "x3", ",", "double", "y3", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "devp", "->", "x", "=", "x3", ";", "devp", "->", "y", "=", "y3", ";", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "g2_triangle_pd", "(", "devp", "->", "d", ".", "pd", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "x3", ",", "y3", ")", ";", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "g2_triangle", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "x3", ",", "y3", ")", ";", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "if", "(", "devp", "->", "auto_flush", ")", "g2_flush", "(", "dev", ")", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Draw", "a", "triangle", "described", "by", "3", "corner", "points", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "x1", "type": "double" }, { "param": "y1", "type": "double" }, { "param": "x2", "type": "double" }, { "param": "y2", "type": "double" }, { "param": "x3", "type": "double" }, { "param": "y3", "type": "double" } ]

[ "Python-2.0" ]

[ "Draw", "a", "filled", "triangle", "specified", "by", "the", "3", "corner", "points", ".", "\\", "ingroup", "graphic" ]

[ "void", "g2_filled_triangle", "(", "int", "dev", ",", "double", "x1", ",", "double", "y1", ",", "double", "x2", ",", "double", "y2", ",", "double", "x3", ",", "double", "y3", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "devp", "->", "x", "=", "x3", ";", "devp", "->", "y", "=", "y3", ";", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "g2_filled_triangle_pd", "(", "devp", "->", "d", ".", "pd", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "x3", ",", "y3", ")", ";", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "g2_filled_triangle", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "x3", ",", "y3", ")", ";", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "if", "(", "devp", "->", "auto_flush", ")", "g2_flush", "(", "dev", ")", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Draw", "a", "filled", "triangle", "specified", "by", "the", "3", "corner", "points", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "x1", "type": "double" }, { "param": "y1", "type": "double" }, { "param": "x2", "type": "double" }, { "param": "y2", "type": "double" }, { "param": "x3", "type": "double" }, { "param": "y3", "type": "double" } ]

[ "Python-2.0" ]

[ "Draw", "a", "rectangle", "specified", "by", "the", "two", "opposite", "corner", "points", ".", "\\", "ingroup", "graphic" ]

[ "void", "g2_rectangle", "(", "int", "dev", ",", "double", "x1", ",", "double", "y1", ",", "double", "x2", ",", "double", "y2", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "devp", "->", "x", "=", "x2", ";", "devp", "->", "y", "=", "y2", ";", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "g2_rectangle_pd", "(", "devp", "->", "d", ".", "pd", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ")", ";", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "g2_rectangle", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ")", ";", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "if", "(", "devp", "->", "auto_flush", ")", "g2_flush", "(", "dev", ")", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Draw", "a", "rectangle", "specified", "by", "the", "two", "opposite", "corner", "points", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "x1", "type": "double" }, { "param": "y1", "type": "double" }, { "param": "x2", "type": "double" }, { "param": "y2", "type": "double" } ]

[ "Python-2.0" ]

[ "Draw", "a", "filled", "rectangle", "specified", "by", "the", "two", "opposite", "corner", "points", ".", "\\", "ingroup", "graphic" ]

[ "void", "g2_filled_rectangle", "(", "int", "dev", ",", "double", "x1", ",", "double", "y1", ",", "double", "x2", ",", "double", "y2", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "devp", "->", "x", "=", "x2", ";", "devp", "->", "y", "=", "y2", ";", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "g2_filled_rectangle_pd", "(", "devp", "->", "d", ".", "pd", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ")", ";", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "g2_filled_rectangle", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ")", ";", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "if", "(", "devp", "->", "auto_flush", ")", "g2_flush", "(", "dev", ")", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Draw", "a", "filled", "rectangle", "specified", "by", "the", "two", "opposite", "corner", "points", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "x1", "type": "double" }, { "param": "y1", "type": "double" }, { "param": "x2", "type": "double" }, { "param": "y2", "type": "double" } ]

[ "Python-2.0" ]

[ "Draw", "a", "filled", "circle", ".", "\\", "param", "dev", "device", "\\", "param", "x", "x", "coordinate", "of", "the", "center", "\\", "param", "y", "y", "coordinate", "of", "the", "center", "\\", "param", "r", "radius", "\\", "ingroup", "graphic" ]

[ "void", "g2_filled_circle", "(", "int", "dev", ",", "double", "x", ",", "double", "y", ",", "double", "r", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "devp", "->", "x", "=", "x", ";", "devp", "->", "y", "=", "y", ";", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "g2_filled_circle_pd", "(", "devp", "->", "d", ".", "pd", ",", "x", ",", "y", ",", "r", ")", ";", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "g2_filled_circle", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "x", ",", "y", ",", "r", ")", ";", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "if", "(", "devp", "->", "auto_flush", ")", "g2_flush", "(", "dev", ")", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Draw", "a", "filled", "circle", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "x", "type": "double" }, { "param": "y", "type": "double" }, { "param": "r", "type": "double" } ]

[ "Python-2.0" ]

[ "Quasi", "Pixel", "fake", ".", "Quasi", "pixel", "is", "introduced", "to", "make", "easier", "plotting", "of", "cellular", "automata", "and", "related", "pictures", ".", "QP", "is", "simple", "a", "big", "pixel", "as", "specified", "by", "g2_set_QP", "()", ".", "Coordinates", "are", "skaled", "accordingly", "so", "no", "recalculation", "is", "needed", "on", "client", "side", ".", "\\", "param", "dev", "device", "\\", "param", "x", "x", "coordinate", "\\", "param", "y", "y", "coordinate", "\\", "ingroup", "graphic" ]

[ "void", "g2_plot_QP", "(", "int", "dev", ",", "double", "x", ",", "double", "y", ")", "{", "g2_device", "*", "devp", ";", "double", "d", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "x", "=", "dtoi", "(", "x", ")", ";", "y", "=", "dtoi", "(", "y", ")", ";", "d", "=", "devp", "->", "QPd", ";", "switch", "(", "devp", "->", "QPshape", ")", "{", "case", "QPrect", ":", "g2_filled_rectangle", "(", "dev", ",", "x", "*", "d", "-", "d", "/", "2", ",", "y", "*", "d", "-", "d", "/", "2", ",", "x", "*", "d", "+", "d", "/", "2", ",", "y", "*", "d", "+", "d", "/", "2", ")", ";", "break", ";", "case", "QPcirc", ":", "g2_filled_circle", "(", "dev", ",", "x", "*", "d", ",", "y", "*", "d", ",", "d", "/", "2.0", ")", ";", "break", ";", "default", ":", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ")", ";", "break", ";", "}", "if", "(", "devp", "->", "auto_flush", ")", "g2_flush", "(", "dev", ")", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Quasi", "Pixel", "fake", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "x", "type": "double" }, { "param": "y", "type": "double" } ]

[ "Python-2.0" ]

[ "Return", "1", "if", "dev", "is", "attached", "to", "vd" ]

[ "int", "g2_is_attached", "(", "int", "vd", ",", "int", "dev", ")", "{", "g2_device", "*", "vdp", ",", "*", "devp", ";", "int", "i", ";", "if", "(", "vd", "==", "dev", ")", "return", "1", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "return", "0", ";", "if", "(", "(", "vdp", "=", "g2_get_device_pointer", "(", "vd", ")", ")", "==", "NULL", ")", "return", "0", ";", "if", "(", "devp", "==", "vdp", ")", "return", "1", ";", "if", "(", "vdp", "->", "t", "!=", "g2_VD", ")", "return", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "vdp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "{", "if", "(", "vdp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", "==", "dev", ")", "return", "1", ";", "if", "(", "g2_is_attached", "(", "vdp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "dev", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}" ]

[ "Return", "1", "if", "dev", "is", "attached", "to", "vd" ]

[]

[ { "param": "vd", "type": "int" }, { "param": "dev", "type": "int" } ]

[ "Python-2.0" ]

[ "using", "sscanf", "instead", "of", "strcpy", "get", "'", "s", "rid", "of", "trainling", "junk", "on", "the", "input", "line" ]

[ "void", "tokenize", "(", "char", "*", "line", ",", "char", "*", "*", "seq1", ",", "char", "*", "*", "seq2", ")", "{", "char", "*", "pos", ";", "int", "cut", "=", "-1", ";", "pos", "=", "strchr", "(", "line", ",", "'", "'", ")", ";", "if", "(", "pos", ")", "{", "cut", "=", "(", "int", ")", "(", "pos", "-", "line", ")", "+", "1", ";", "(", "*", "seq1", ")", "=", "(", "char", "*", ")", "vrna_alloc", "(", "(", "cut", "+", "1", ")", "*", "sizeof", "(", "char", ")", ")", ";", "(", "*", "seq2", ")", "=", "(", "char", "*", ")", "vrna_alloc", "(", "(", "(", "strlen", "(", "line", ")", "-", "cut", ")", "+", "2", ")", "*", "sizeof", "(", "char", ")", ")", ";", "if", "(", "strchr", "(", "pos", "+", "1", ",", "'", "'", ")", ")", "vrna_message_error", "(", "\"", "\"", ")", ";", "*", "pos", "=", "'", "\\0", "'", ";", "(", "void", ")", "sscanf", "(", "line", ",", "\"", "\"", ",", "*", "seq1", ")", ";", "(", "void", ")", "sscanf", "(", "pos", "+", "1", ",", "\"", "\"", ",", "*", "seq2", ")", ";", "}", "else", "{", "(", "*", "seq1", ")", "=", "(", "char", "*", ")", "vrna_alloc", "(", "(", "strlen", "(", "line", ")", "+", "1", ")", "*", "sizeof", "(", "char", ")", ")", ";", "(", "*", "seq2", ")", "=", "NULL", ";", "sscanf", "(", "line", ",", "\"", "\"", ",", "*", "seq1", ")", ";", "}", "if", "(", "cut", ">", "-1", ")", "{", "if", "(", "cut_point", "==", "-1", ")", "{", "cut_point", "=", "cut", ";", "}", "else", "if", "(", "cut_point", "!=", "cut", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "cut_point", ",", "cut", ")", ";", "vrna_message_error", "(", "\"", "\"", ")", ";", "}", "}", "free", "(", "line", ")", ";", "return", ";", "}" ]

[ "using", "sscanf", "instead", "of", "strcpy", "get", "'", "s", "rid", "of", "trainling", "junk", "on", "the", "input", "line" ]

[]

[ { "param": "line", "type": "char" }, { "param": "seq1", "type": "char" }, { "param": "seq2", "type": "char" } ]

[ "Python-2.0" ]

[ "len1", "is", "the", "length", "of", "the", "LONGER", "input", "seq", "!" ]

[ "void", "seperate_bp", "(", "char", "*", "*", "inter", ",", "int", "len1", ",", "char", "*", "*", "intra_l", ",", "char", "*", "*", "intra_s", ")", "{", "int", "i", ",", "j", ",", "len", ";", "short", "*", "pt", "=", "NULL", ";", "char", "*", "temp_inter", ",", "*", "pt_inter", ";", "len", "=", "strlen", "(", "(", "*", "inter", ")", ")", ";", "i", "=", "len", "+", "1", ";", "temp_inter", "=", "(", "char", "*", ")", "vrna_alloc", "(", "sizeof", "(", "char", ")", "*", "i", ")", ";", "pt_inter", "=", "(", "char", "*", ")", "vrna_alloc", "(", "sizeof", "(", "char", ")", "*", "i", ")", ";", "temp_inter", "[", "strlen", "(", "(", "*", "inter", ")", ")", "]", "=", "'", "\\0", "'", ";", "pt_inter", "[", "strlen", "(", "(", "*", "inter", ")", ")", "]", "=", "'", "\\0", "'", ";", "if", "(", "cut_point", "<", "len1", ")", "{", "for", "(", "j", "=", "0", ",", "i", "=", "cut_point", "-", "1", ";", "i", "<", "len", ";", "i", "++", ",", "j", "++", ")", "{", "switch", "(", "(", "*", "inter", ")", "[", "i", "]", ")", "{", "case", "'", "'", ":", "temp_inter", "[", "j", "]", "=", "'", "'", ";", "pt_inter", "[", "j", "]", "=", "'", "'", ";", "break", ";", "case", "'", "'", ":", "temp_inter", "[", "j", "]", "=", "'", "'", ";", "pt_inter", "[", "j", "]", "=", "'", "'", ";", "break", ";", "default", ":", "temp_inter", "[", "j", "]", "=", "(", "*", "inter", ")", "[", "i", "]", ";", "pt_inter", "[", "j", "]", "=", "'", "'", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "cut_point", "-", "1", ";", "i", "++", ",", "j", "++", ")", "{", "switch", "(", "(", "*", "inter", ")", "[", "i", "]", ")", "{", "case", "'", "'", ":", "temp_inter", "[", "j", "]", "=", "'", "'", ";", "pt_inter", "[", "j", "]", "=", "'", "'", ";", "break", ";", "case", "'", "'", ":", "temp_inter", "[", "j", "]", "=", "'", "'", ";", "pt_inter", "[", "j", "]", "=", "'", "'", ";", "break", ";", "default", ":", "temp_inter", "[", "j", "]", "=", "(", "*", "inter", ")", "[", "i", "]", ";", "pt_inter", "[", "j", "]", "=", "'", "'", ";", "}", "}", "cut_point", "=", "len1", "+", "1", ";", "strcpy", "(", "(", "*", "inter", ")", ",", "temp_inter", ")", ";", "}", "else", "{", "for", "(", "i", "=", "0", ";", "i", "<", "strlen", "(", "(", "*", "inter", ")", ")", ";", "i", "++", ")", "{", "switch", "(", "(", "*", "inter", ")", "[", "i", "]", ")", "{", "case", "'", "'", ":", "pt_inter", "[", "i", "]", "=", "'", "'", ";", "break", ";", "case", "'", "'", ":", "pt_inter", "[", "i", "]", "=", "'", "'", ";", "break", ";", "default", ":", "pt_inter", "[", "i", "]", "=", "'", "'", ";", "}", "}", "}", "pt", "=", "vrna_ptable", "(", "pt_inter", ")", ";", "(", "*", "intra_l", ")", "=", "(", "char", "*", ")", "vrna_alloc", "(", "sizeof", "(", "char", ")", "*", "(", "len1", "+", "1", ")", ")", ";", "(", "*", "intra_s", ")", "=", "(", "char", "*", ")", "vrna_alloc", "(", "sizeof", "(", "char", ")", "*", "(", "strlen", "(", "(", "*", "inter", ")", ")", "-", "len1", "+", "2", ")", ")", ";", "(", "*", "intra_l", ")", "[", "len1", "]", "=", "'", "\\0", "'", ";", "(", "*", "intra_s", ")", "[", "strlen", "(", "(", "*", "inter", ")", ")", "-", "len1", "+", "1", "]", "=", "'", "\\0", "'", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "pt", "[", "0", "]", ";", "i", "++", ")", "{", "if", "(", "pt", "[", "i", "]", "==", "0", ")", "{", "temp_inter", "[", "i", "-", "1", "]", "=", "(", "*", "inter", ")", "[", "i", "-", "1", "]", ";", "if", "(", "i", "<", "cut_point", ")", "{", "(", "*", "intra_l", ")", "[", "i", "-", "1", "]", "=", "(", "*", "inter", ")", "[", "i", "-", "1", "]", ";", "if", "(", "(", "*", "inter", ")", "[", "i", "-", "1", "]", "==", "'", "'", ")", "(", "*", "intra_l", ")", "[", "i", "-", "1", "]", "=", "'", "'", ";", "}", "else", "{", "(", "*", "intra_s", ")", "[", "i", "-", "cut_point", "]", "=", "(", "*", "inter", ")", "[", "i", "-", "1", "]", ";", "if", "(", "(", "*", "inter", ")", "[", "i", "-", "1", "]", "==", "'", "'", ")", "(", "*", "intra_s", ")", "[", "i", "-", "cut_point", "]", "=", "'", "'", ";", "}", "}", "else", "{", "if", "(", "i", "<", "cut_point", ")", "{", "if", "(", "pt", "[", "i", "]", ">=", "cut_point", ")", "{", "temp_inter", "[", "i", "-", "1", "]", "=", "(", "*", "inter", ")", "[", "i", "-", "1", "]", ";", "(", "*", "intra_l", ")", "[", "i", "-", "1", "]", "=", "'", "'", ";", "(", "*", "intra_s", ")", "[", "pt", "[", "i", "]", "-", "cut_point", "]", "=", "'", "'", ";", "}", "else", "{", "(", "*", "intra_l", ")", "[", "i", "-", "1", "]", "=", "(", "*", "inter", ")", "[", "i", "-", "1", "]", ";", "temp_inter", "[", "i", "-", "1", "]", "=", "'", "'", ";", "}", "}", "else", "{", "if", "(", "pt", "[", "i", "]", "<", "cut_point", ")", "{", "temp_inter", "[", "i", "-", "1", "]", "=", "(", "*", "inter", ")", "[", "i", "-", "1", "]", ";", "}", "else", "{", "(", "*", "intra_s", ")", "[", "i", "-", "cut_point", "]", "=", "(", "*", "inter", ")", "[", "i", "-", "1", "]", ";", "temp_inter", "[", "i", "-", "1", "]", "=", "'", "'", ";", "}", "}", "}", "}", "strcpy", "(", "(", "*", "inter", ")", ",", "temp_inter", ")", ";", "free", "(", "temp_inter", ")", ";", "free", "(", "pt_inter", ")", ";", "free", "(", "pt", ")", ";", "}" ]

[ "len1", "is", "the", "length", "of", "the", "LONGER", "input", "seq", "!" ]

[ "/* printf(\"inter\\n%s\\n\",(*inter)); */", "/* to make a pair_table convert <|> to (|) */", "/* if shorter seq is first seq in constrained string, write the\n * longer one as the first one */", "/* write the constrain for the longer seq first */", "/* then add the constrain for the shorter seq */", "/* intramolecular structure in longer (_l) and shorter (_s) seq */", "/* now seperate intermolecular from intramolecular bp */", "/* intermolekular bp */", "/* intramolekular bp */", "/* i>=cut_point */", "/* intermolekular bp */", "/* (*intra_s)[i-1] = '.'; */", "/* intramolekular bp */", "/* printf(\"%s -1\\n%s -2\\n%s -3\\n%s -4\\n\",(*inter),temp_inter,(*intra_l),(*intra_s)); */" ]

[ { "param": "inter", "type": "char" }, { "param": "len1", "type": "int" }, { "param": "intra_l", "type": "char" }, { "param": "intra_s", "type": "char" } ]

[ "Python-2.0" ]

[ "Assign", "a", "pointer", "link", "to", "a", "vertex", ".", "Edge", "e", "joins", "a", "vertex", "in", "blossom", "u", "to", "a", "linked", "vertex", "." ]

[ "void", "POINTER", "(", "int", "u", ",", "int", "v", ",", "int", "e", ")", "{", "int", "i", ",", "del", ";", "#ifdef", "DEBUG", "printf", "(", "\"", "\\n", "\"", ",", "u", ",", "v", ",", "END", "[", "OPPEDGE", "(", "e", ")", "]", ",", "END", "[", "e", "]", ")", ";", "#endif", "LINK", "[", "u", "]", "=", "-", "DUMMYEDGE", ";", "NEXTVTX", "[", "LASTVTX", "[", "u", "]", "]", "=", "DUMMYVERTEX", ";", "NEXTVTX", "[", "LASTVTX", "[", "v", "]", "]", "=", "DUMMYVERTEX", ";", "if", "(", "LASTVTX", "[", "u", "]", "!=", "u", ")", "{", "i", "=", "MATE", "[", "NEXTVTX", "[", "u", "]", "]", ";", "del", "=", "-", "SLACK", "(", "i", ")", "/", "2", ";", "}", "else", "del", "=", "LAST_D", ";", "i", "=", "u", ";", "while", "(", "i", "!=", "DUMMYVERTEX", ")", "{", "Y", "[", "i", "]", "+=", "del", ";", "NEXT_D", "[", "i", "]", "+=", "del", ";", "i", "=", "NEXTVTX", "[", "i", "]", ";", "}", "if", "(", "LINK", "[", "v", "]", "<", "0", ")", "{", "LINK", "[", "v", "]", "=", "e", ";", "NEXTPAIR", "[", "DUMMYEDGE", "]", "=", "DUMMYEDGE", ";", "SCAN", "(", "v", ",", "DELTA", ")", ";", "return", ";", "}", "else", "{", "LINK", "[", "v", "]", "=", "e", ";", "return", ";", "}", "}" ]

[ "Assign", "a", "pointer", "link", "to", "a", "vertex", "." ]

[]

[ { "param": "u", "type": "int" }, { "param": "v", "type": "int" }, { "param": "e", "type": "int" } ]

[ "Python-2.0" ]

[ "Scan", "each", "vertex", "in", "the", "blossom", "whose", "base", "is", "x" ]

[ "void", "SCAN", "(", "int", "x", ",", "int", "del", ")", "{", "int", "u", ",", "del_e", ";", "#ifdef", "DEBUG", "printf", "(", "\"", "\\n", "\"", ",", "del", ",", "x", ")", ";", "#endif", "newbase", "=", "BASE", "[", "x", "]", ";", "stopscan", "=", "NEXTVTX", "[", "LASTVTX", "[", "x", "]", "]", ";", "while", "(", "x", "!=", "stopscan", ")", "{", "Y", "[", "x", "]", "+=", "del", ";", "NEXT_D", "[", "x", "]", "=", "LAST_D", ";", "pairpoint", "=", "DUMMYEDGE", ";", "e", "=", "A", "[", "x", "]", ";", "while", "(", "e", "!=", "0", ")", "{", "neighbor", "=", "END", "[", "e", "]", ";", "u", "=", "BASE", "[", "neighbor", "]", ";", "if", "(", "LINK", "[", "u", "]", "<", "0", ")", "{", "if", "(", "LINK", "[", "BMATE", "(", "u", ")", "]", "<", "0", "||", "LASTVTX", "[", "u", "]", "!=", "u", ")", "{", "del_e", "=", "SLACK", "(", "e", ")", ";", "if", "(", "NEXT_D", "[", "neighbor", "]", ">", "del_e", ")", "{", "NEXT_D", "[", "neighbor", "]", "=", "del_e", ";", "NEXTEDGE", "[", "neighbor", "]", "=", "e", ";", "}", "}", "}", "else", "if", "(", "u", "!=", "newbase", ")", "{", "INSERT_PAIR", "(", ")", ";", "}", "e", "=", "A", "[", "e", "]", ";", "}", "x", "=", "NEXTVTX", "[", "x", "]", ";", "}", "NEXTEDGE", "[", "newbase", "]", "=", "NEXTPAIR", "[", "DUMMYEDGE", "]", ";", "}" ]

[ "Scan", "each", "vertex", "in", "the", "blossom", "whose", "base", "is", "x" ]

[]

[ { "param": "x", "type": "int" }, { "param": "del", "type": "int" } ]

[ "Python-2.0" ]

[ "updates", "numerical", "bounds", "for", "linking", "paths", ".", "called", "with", "LAST_D", "set", "to", "the", "bound", "on", "DELTA", "for", "the", "next", "search" ]

[ "void", "SET_BOUNDS", "(", ")", "{", "int", "del", ";", "for", "(", "v", "=", "1", ";", "v", "<=", "U", ";", "++", "v", ")", "{", "if", "(", "LINK", "[", "v", "]", "<", "0", "||", "BASE", "[", "v", "]", "!=", "v", ")", "{", "NEXT_D", "[", "v", "]", "=", "LAST_D", ";", "continue", ";", "}", "LINK", "[", "v", "]", "=", "-", "LINK", "[", "v", "]", ";", "i", "=", "v", ";", "while", "(", "i", "!=", "DUMMYVERTEX", ")", "{", "Y", "[", "i", "]", "-=", "DELTA", ";", "i", "=", "NEXTVTX", "[", "i", "]", ";", "}", "f", "=", "MATE", "[", "v", "]", ";", "if", "(", "f", "!=", "DUMMYEDGE", ")", "{", "i", "=", "BEND", "(", "f", ")", ";", "del", "=", "SLACK", "(", "f", ")", ";", "while", "(", "i", "!=", "DUMMYVERTEX", ")", "{", "Y", "[", "i", "]", "-=", "del", ";", "i", "=", "NEXTVTX", "[", "i", "]", ";", "}", "}", "NEXT_D", "[", "v", "]", "=", "LAST_D", ";", "}", "}" ]

[ "updates", "numerical", "bounds", "for", "linking", "paths", "." ]

[]

[]

[ "Python-2.0" ]

[ "undoes", "all", "blossoms", "to", "get", "the", "final", "matching" ]

[ "void", "UNPAIR_ALL", "(", ")", "{", "int", "u", ";", "for", "(", "v", "=", "1", ";", "v", "<=", "U", ";", "++", "v", ")", "{", "if", "(", "BASE", "[", "v", "]", "!=", "v", "||", "LASTVTX", "[", "v", "]", "==", "v", ")", "continue", ";", "nextu", "=", "v", ";", "NEXTVTX", "[", "LASTVTX", "[", "nextu", "]", "]", "=", "DUMMYVERTEX", ";", "while", "(", "1", ")", "{", "u", "=", "nextu", ";", "nextu", "=", "NEXTVTX", "[", "nextu", "]", ";", "UNLINK", "(", "u", ")", ";", "if", "(", "LASTVTX", "[", "u", "]", "!=", "u", ")", "{", "f", "=", "(", "LASTEDGE", "[", "2", "]", "==", "OPPEDGE", "(", "e", ")", ")", "?", "LASTEDGE", "[", "1", "]", ":", "LASTEDGE", "[", "2", "]", ";", "NEXTVTX", "[", "LASTVTX", "[", "BEND", "(", "f", ")", "]", "]", "=", "u", ";", "}", "newbase", "=", "BMATE", "(", "BMATE", "(", "u", ")", ")", ";", "if", "(", "newbase", "!=", "DUMMYVERTEX", "&&", "newbase", "!=", "u", ")", "{", "LINK", "[", "u", "]", "=", "-", "DUMMYEDGE", ";", "REMATCH", "(", "newbase", ",", "MATE", "[", "u", "]", ")", ";", "}", "while", "(", "LASTVTX", "[", "nextu", "]", "==", "nextu", "&&", "nextu", "!=", "DUMMYVERTEX", ")", "nextu", "=", "NEXTVTX", "[", "nextu", "]", ";", "if", "(", "LASTVTX", "[", "nextu", "]", "==", "nextu", "&&", "nextu", "==", "DUMMYVERTEX", ")", "break", ";", "}", "}", "}" ]

[ "undoes", "all", "blossoms", "to", "get", "the", "final", "matching" ]

[]

[]

[ "Python-2.0" ]

[ "Add", "work", "to", "the", "thread", "pool" ]

[ "int", "thpool_add_work", "(", "thpool_", "*", "thpool_p", ",", "void", "(", "*", "function_p", ")", "(", "void", "*", ")", ",", "void", "*", "arg_p", ")", "{", "job", "*", "newjob", ";", "newjob", "=", "(", "struct", "job", "*", ")", "malloc", "(", "sizeof", "(", "struct", "job", ")", ")", ";", "if", "(", "newjob", "==", "NULL", ")", "{", "err", "(", "\"", "\\n", "\"", ")", ";", "return", "-1", ";", "}", "newjob", "->", "function", "=", "function_p", ";", "newjob", "->", "arg", "=", "arg_p", ";", "jobqueue_push", "(", "&", "thpool_p", "->", "jobqueue", ",", "newjob", ")", ";", "thpool_p", "->", "num_jobs_placed", "++", ";", "return", "0", ";", "}" ]

[ "Add", "work", "to", "the", "thread", "pool" ]

[ "/* add function and argument */", "/* add job to queue */", "/* increment the job placed count */" ]

[ { "param": "thpool_p", "type": "thpool_" }, { "param": "function_p", "type": "void" }, { "param": "arg_p", "type": "void" } ]

[ "Python-2.0" ]

[ "Initialize", "a", "thread", "in", "the", "thread", "pool", "@param", "thread", "address", "to", "the", "pointer", "of", "the", "thread", "to", "be", "created", "@param", "id", "id", "to", "be", "given", "to", "the", "thread", "@return", "0", "on", "success", "-", "1", "otherwise", "." ]

[ "static", "int", "thread_init", "(", "thpool_", "*", "thpool_p", ",", "struct", "thread", "*", "*", "thread_p", ",", "int", "id", ")", "{", "*", "thread_p", "=", "(", "struct", "thread", "*", ")", "malloc", "(", "sizeof", "(", "struct", "thread", ")", ")", ";", "if", "(", "thread_p", "==", "NULL", ")", "{", "err", "(", "\"", "\\n", "\"", ")", ";", "return", "-1", ";", "}", "(", "*", "thread_p", ")", "->", "thpool_p", "=", "thpool_p", ";", "(", "*", "thread_p", ")", "->", "id", "=", "id", ";", "pthread_create", "(", "&", "(", "*", "thread_p", ")", "->", "pthread", ",", "NULL", ",", "(", "void", "*", ")", "thread_do", ",", "(", "*", "thread_p", ")", ")", ";", "pthread_detach", "(", "(", "*", "thread_p", ")", "->", "pthread", ")", ";", "return", "0", ";", "}" ]

[ "Initialize", "a", "thread", "in", "the", "thread", "pool", "@param", "thread", "address", "to", "the", "pointer", "of", "the", "thread", "to", "be", "created", "@param", "id", "id", "to", "be", "given", "to", "the", "thread", "@return", "0", "on", "success", "-", "1", "otherwise", "." ]

[]

[ { "param": "thpool_p", "type": "thpool_" }, { "param": "thread_p", "type": "struct thread" }, { "param": "id", "type": "int" } ]

[ "Python-2.0" ]

[ "Clear", "collor", "palette", "(", "remove", "all", "inks", ")", "and", "reallocate", "basic", "colors", ".", "\\", "param", "dev", "device", "\\", "ingroup", "color" ]

[ "void", "g2_reset_palette", "(", "int", "dev", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "g2_clear_palette", "(", "dev", ")", ";", "g2_allocate_basic_colors", "(", "dev", ")", ";", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "g2_reset_palette", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ")", ";", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Clear", "collor", "palette", "(", "remove", "all", "inks", ")", "and", "reallocate", "basic", "colors", "." ]

[]

[ { "param": "dev", "type": "int" } ]

[ "Python-2.0" ]

[ "Query", "pointer", "position", "and", "button", "state", ".", "See", "the", "demo", "program", "pointer", ".", "c", "for", "an", "example", ".", "\\", "param", "dev", "device", "\\", "param", "x", "returns", "pointer", "x", "coordinate", "\\", "param", "y", "returns", "pointer", "y", "coordinate", "\\", "param", "button", "returns", "button", "state", "\\", "ingroup", "control" ]

[ "void", "g2_query_pointer", "(", "int", "dev", ",", "double", "*", "x", ",", "double", "*", "y", ",", "unsigned", "int", "*", "button", ")", "{", "g2_device", "*", "devp", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "g2_query_pointer_pd", "(", "devp", "->", "d", ".", "pd", ",", "x", ",", "y", ",", "button", ")", ";", "break", ";", "case", "g2_VD", ":", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Query", "pointer", "(", "e", ".", "g", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "x", "type": "double" }, { "param": "y", "type": "double" }, { "param": "button", "type": "unsigned int" } ]

[ "Python-2.0" ]

[ "Get", "pointers", "to", "physical", "device", "specific", "handles", ".", "This", "function", "should", "be", "used", "only", "if", "you", "are", "familiar", "with", "the", "g2", "source", "code", ".", "For", "details", "see", "physical", "device", "source", "code", ".", "Example", "usage", "can", "be", "found", "in", "demo", "/", "handles", ".", "c", ".", "\\", "param", "pd", "physical", "device", "\\", "param", "handles", "returns", "pointers", "to", "physical", "device", "low", "level", "handles", "\\", "ingroup", "control" ]

[ "void", "g2_get_pd_handles", "(", "int", "pd", ",", "void", "*", "handles", "[", "G2_PD_HANDLES_SIZE", "]", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "G2_PD_HANDLES_SIZE", ";", "i", "++", ")", "{", "handles", "[", "i", "]", "=", "NULL", ";", "}", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "pd", ")", ")", "==", "NULL", ")", "{", "g2_log", "(", "Error", ",", "\"", "\\n", "\"", ",", "pd", ")", ";", "return", ";", "}", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "g2_get_pd_handles_pd", "(", "devp", "->", "d", ".", "pd", ",", "handles", ")", ";", "break", ";", "case", "g2_VD", ":", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "}" ]

[ "Get", "pointers", "to", "physical", "device", "specific", "handles", "." ]

[]

[ { "param": "pd", "type": "int" }, { "param": "handles", "type": "void" } ]

[ "Python-2.0" ]

[ "Use", "volatile", "tmp", "variable", "to", "prevent", "optimization", "by", "compiler", "." ]

[ "static", "inline", "int", "isnan_f", "(", "float", "x", ")", "{", "volatile", "float", "tmp", "=", "x", ";", "return", "tmp", "!=", "x", ";", "}" ]

[ "Use", "volatile", "tmp", "variable", "to", "prevent", "optimization", "by", "compiler", "." ]

[]

[ { "param": "x", "type": "float" } ]

[ "Python-2.0" ]

[ "Query", "pointer", "position", "and", "button", "state" ]

[ "void", "g2_query_pointer_pd", "(", "g2_physical_device", "*", "pd", ",", "double", "*", "x", ",", "double", "*", "y", ",", "unsigned", "int", "*", "button", ")", "{", "int", "ix", ",", "iy", ";", "double", "dx", ",", "dy", ";", "if", "(", "pd", "->", "ff", "[", "g2_QueryPointer", "]", ".", "fun", "!=", "NULL", ")", "{", "switch", "(", "pd", "->", "coor_type", ")", "{", "case", "g2_IntCoor", ":", "pd", "->", "ff", "[", "g2_QueryPointer", "]", ".", "fun", "(", "pd", "->", "pid", ",", "pd", "->", "pdp", ",", "&", "ix", ",", "&", "iy", ",", "button", ")", ";", "g2_pdc2uc", "(", "pd", ",", "ix", ",", "iy", ",", "x", ",", "y", ")", ";", "break", ";", "case", "g2_DoubleCoor", ":", "pd", "->", "ff", "[", "g2_QueryPointer", "]", ".", "fun", "(", "pd", "->", "pid", ",", "pd", "->", "pdp", ",", "&", "dx", ",", "&", "dy", ",", "button", ")", ";", "g2_pdc2uc", "(", "pd", ",", "dx", ",", "dy", ",", "x", ",", "y", ")", ";", "break", ";", "}", "}", "else", "{", "}", "}" ]

[ "Query", "pointer", "position", "and", "button", "state" ]

[ "/* no emulation for query pointer */" ]

[ { "param": "pd", "type": "g2_physical_device" }, { "param": "x", "type": "double" }, { "param": "y", "type": "double" }, { "param": "button", "type": "unsigned int" } ]

[ "Python-2.0" ]

[ "returns", "NULL", "unless", "x", "is", "in", "the", "cache" ]

[ "cache_entry", "*", "lookup_cache", "(", "char", "*", "x", ")", "{", "int", "cacheval", ";", "cache_entry", "*", "c", ";", "cacheval", "=", "cache_f", "(", "x", ")", ";", "if", "(", "(", "c", "=", "cachetab", "[", "cacheval", "]", ")", ")", "if", "(", "strcmp", "(", "c", "->", "structure", ",", "x", ")", "==", "0", ")", "return", "c", ";", "return", "NULL", ";", "}" ]

[ "returns", "NULL", "unless", "x", "is", "in", "the", "cache" ]

[]

[ { "param": "x", "type": "char" } ]

[ "Python-2.0" ]

[ "returns", "1", "if", "x", "already", "was", "in", "the", "cache" ]

[ "int", "write_cache", "(", "cache_entry", "*", "x", ")", "{", "int", "cacheval", ";", "cache_entry", "*", "c", ";", "cacheval", "=", "cache_f", "(", "x", "->", "structure", ")", ";", "if", "(", "(", "c", "=", "cachetab", "[", "cacheval", "]", ")", ")", "{", "free", "(", "c", "->", "structure", ")", ";", "free", "(", "c", "->", "neighbors", ")", ";", "free", "(", "c", "->", "rates", ")", ";", "free", "(", "c", "->", "energies", ")", ";", "free", "(", "c", ")", ";", "}", "cachetab", "[", "cacheval", "]", "=", "x", ";", "return", "0", ";", "}" ]

[ "returns", "1", "if", "x", "already", "was", "in", "the", "cache" ]

[]

[ { "param": "x", "type": "cache_entry" } ]

[ "Python-2.0" ]

[ "0", "is", "equal", "1", "is", "different!" ]

[ "static", "int", "hash_comparison_dos", "(", "void", "*", "x", ",", "void", "*", "y", ")", "{", "key_value", "*", "hem_x", "=", "(", "(", "key_value", "*", ")", "x", ")", ";", "key_value", "*", "hem_y", "=", "(", "(", "key_value", "*", ")", "y", ")", ";", "if", "(", "(", "x", "==", "NULL", ")", "^", "(", "y", "==", "NULL", ")", ")", "return", "1", ";", "return", "!", "(", "hem_x", "->", "key", "==", "hem_y", "->", "key", ")", ";", "}" ]

[ "0", "is", "equal", "1", "is", "different!" ]

[]

[ { "param": "x", "type": "void" }, { "param": "y", "type": "void" } ]

[ "Python-2.0" ]

[ "Set", "auto", "flush", "mode", "for", "device", "\\", "a", "dev", ".", "Auto", "flush", "mode", "means", "that", "after", "each", "graphical", "operation", "g2", "library", "automatically", "calls", "flush", "function", "to", "ensure", "that", "output", "is", "realy", "displayed", ".", "However", "freqent", "flushing", "decreases", "performance", ".", "Alternative", "is", "to", "flush", "output", "when", "needed", "by", "calling", "g2_flush", "function", ".", "\\", "param", "dev", "device", "\\", "param", "on_off", "1", "-", "on", "0", "-", "off", "\\", "ingroup", "device" ]

[ "void", "g2_set_auto_flush", "(", "int", "dev", ",", "int", "on_off", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "g2_log", "(", "Error", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "{", "g2_set_auto_flush", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "on_off", ")", ";", "}", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "devp", "->", "auto_flush", "=", "on_off", ";", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Set", "auto", "flush", "mode", "for", "device", "\\", "a", "dev", "." ]

[ "/* set auto flush for all (vd and pd) devices */" ]

[ { "param": "dev", "type": "int" }, { "param": "on_off", "type": "int" } ]

[ "Python-2.0" ]

[ "Set", "the", "user", "coordinate", "system", ".", "\\", "ingroup", "device" ]

[ "void", "g2_set_coordinate_system", "(", "int", "dev", ",", "double", "x_origin", ",", "double", "y_origin", ",", "double", "x_mul", ",", "double", "y_mul", ")", "{", "g2_device", "*", "devp", ";", "int", "i", ";", "if", "(", "x_mul", "==", "0.0", "||", "y_mul", "==", "0.0", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\"", ")", ";", "return", ";", "}", "if", "(", "(", "devp", "=", "g2_get_device_pointer", "(", "dev", ")", ")", "==", "NULL", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "dev", ")", ";", "return", ";", "}", "switch", "(", "devp", "->", "t", ")", "{", "case", "g2_PD", ":", "devp", "->", "d", ".", "pd", "->", "x_origin", "=", "x_origin", ";", "devp", "->", "d", ".", "pd", "->", "y_origin", "=", "y_origin", ";", "devp", "->", "d", ".", "pd", "->", "x_mul", "=", "x_mul", ";", "devp", "->", "d", ".", "pd", "->", "y_mul", "=", "y_mul", ";", "break", ";", "case", "g2_VD", ":", "for", "(", "i", "=", "0", ";", "i", "<", "devp", "->", "d", ".", "vd", "->", "N", ";", "i", "++", ")", "g2_set_coordinate_system", "(", "devp", "->", "d", ".", "vd", "->", "dix", "[", "i", "]", ",", "x_origin", ",", "y_origin", ",", "x_mul", ",", "y_mul", ")", ";", "break", ";", "case", "g2_ILLEGAL", ":", "break", ";", "case", "g2_NDEV", ":", "break", ";", "}", "__g2_last_device", "=", "dev", ";", "}" ]

[ "Set", "the", "user", "coordinate", "system", "." ]

[]

[ { "param": "dev", "type": "int" }, { "param": "x_origin", "type": "double" }, { "param": "y_origin", "type": "double" }, { "param": "x_mul", "type": "double" }, { "param": "y_mul", "type": "double" } ]

[ "MIT" ]

[ "binary", "search", "for", "name", "in", "tabs", ":", "return", "index" ]

[ "int", "lookup", "(", "char", "*", "name", ",", "Nameval", "tab", "[", "]", ",", "int", "ntab", ")", "{", "int", "low", ",", "high", ",", "mid", ",", "cmp", ";", "low", "=", "0", ";", "high", "=", "ntab", "-", "1", ";", "while", "(", "low", "<=", "high", ")", "{", "mid", "=", "(", "low", "+", "high", ")", "/", "2", ";", "cmp", "=", "strcmp", "(", "name", ",", "tab", "[", "mid", "]", ".", "name", ")", ";", "if", "(", "cmp", "<", "0", ")", "high", "=", "mid", "-", "1", ";", "else", "if", "(", "cmp", ">", "0", ")", "low", "=", "mid", "+", "1", ";", "else", "return", "(", "mid", ")", ";", "}", "return", "(", "-1", ")", ";", "}" ]

[ "lookup", ":", "binary", "search", "for", "name", "in", "tabs", ":", "return", "index" ]

[]

[ { "param": "name", "type": "char" }, { "param": "tab", "type": "Nameval" }, { "param": "ntab", "type": "int" } ]

[ "MIT" ]

[ "Advance", "the", "iterator", "to", "the", "given", "field", "index", ".", "Returns", "false", "when", "the", "iterator", "wraps", "back", "to", "the", "first", "field", "." ]

[ "bool", "jude_iterator_go_to_index", "(", "jude_iterator_t", "*", "iter", ",", "jude_size_t", "index", ")", "{", "const", "jude_field_t", "*", "start", "=", "iter", "->", "current_field", ";", "do", "{", "if", "(", "iter", "->", "field_index", "==", "index", ")", "{", "return", "true", ";", "}", "(", "void", ")", "jude_iterator_next", "(", "iter", ")", ";", "}", "while", "(", "iter", "->", "current_field", "!=", "start", ")", ";", "iter", "->", "field_index", "=", "JUDE_UNKNOWN_FIELD_INDEX", ";", "return", "false", ";", "}" ]

[ "Advance", "the", "iterator", "to", "the", "given", "field", "index", "." ]

[ "/* Found the wanted field */", "/* Searched all the way back to start, and found nothing. */" ]

[ { "param": "iter", "type": "jude_iterator_t" }, { "param": "index", "type": "jude_size_t" } ]

[ "MIT" ]

[ "get", "pointer", "to", "the", "\"", "count", "\"", "variable", "(", "if", "iterator", "not", "pointing", "at", "array", "field", "returns", "NULL", ")" ]

[ "jude_size_t", "*", "jude_iterator_get_count_reference", "(", "jude_iterator_t", "*", "iter", ")", "{", "if", "(", "!", "iter", ")", "return", "NULL", ";", "return", "jude_get_array_count_reference", "(", "iter", "->", "current_field", ",", "iter", "->", "details", ".", "data", ")", ";", "}" ]

[ "get", "pointer", "to", "the", "\"", "count", "\"", "variable", "(", "if", "iterator", "not", "pointing", "at", "array", "field", "returns", "NULL", ")" ]

[]

[ { "param": "iter", "type": "jude_iterator_t" } ]

[ "MIT" ]

[ "Similar", "to", "memcmp", "but", "for", "messages", ".", "This", "is", "important", "because", ":", "-", "We", "need", "to", "ignore", "bitmask", "differences", "that", "just", "show", "different", "fields", "are", "dirty", "-", "We", "need", "to", "ignore", "memory", "differences", "in", "fields", "that", "are", "marked", "unset", "-", "We", "need", "to", "ignore", "memory", "differences", "in", "repeated", "fields", "where", "the", "data", "is", "not", "relevant" ]

[ "int", "jude_object_compare", "(", "const", "jude_object_t", "*", "lhs_struct", ",", "const", "jude_object_t", "*", "rhs_struct", ")", "{", "static", "const", "int", "LhsGreaterThanRhs", "=", "1", ";", "static", "const", "int", "LhsLessThanRhs", "=", "-1", ";", "static", "const", "int", "LhsEqualToRhs", "=", "0", ";", "if", "(", "lhs_struct", "==", "rhs_struct", ")", "return", "LhsEqualToRhs", ";", "if", "(", "lhs_struct", "==", "NULL", ")", "return", "LhsLessThanRhs", ";", "if", "(", "rhs_struct", "==", "NULL", ")", "return", "LhsGreaterThanRhs", ";", "int", "result", ";", "jude_iterator_t", "lhs_iter", "=", "jude_iterator_begin", "(", "jude_remove_const", "(", "lhs_struct", ")", ")", ";", "jude_iterator_t", "rhs_iter", "=", "jude_iterator_begin", "(", "jude_remove_const", "(", "rhs_struct", ")", ")", ";", "do", "{", "bool", "lhs_isset", "=", "jude_filter_is_touched", "(", "lhs_iter", ".", "object", "->", "__mask", ",", "lhs_iter", ".", "field_index", ")", ";", "bool", "rhs_isset", "=", "jude_filter_is_touched", "(", "rhs_iter", ".", "object", "->", "__mask", ",", "rhs_iter", ".", "field_index", ")", ";", "if", "(", "!", "lhs_isset", "&&", "!", "rhs_isset", ")", "{", "continue", ";", "}", "else", "if", "(", "lhs_isset", "&&", "!", "rhs_isset", ")", "{", "return", "LhsGreaterThanRhs", ";", "}", "else", "if", "(", "!", "lhs_isset", "&&", "rhs_isset", ")", "{", "return", "LhsLessThanRhs", ";", "}", "if", "(", "lhs_iter", ".", "current_field", "->", "type", "==", "JUDE_TYPE_OBJECT", ")", "{", "if", "(", "!", "jude_iterator_is_array", "(", "&", "lhs_iter", ")", ")", "{", "result", "=", "jude_object_compare", "(", "lhs_iter", ".", "details", ".", "sub_object", ",", "rhs_iter", ".", "details", ".", "sub_object", ")", ";", "if", "(", "result", "!=", "0", ")", "{", "return", "result", ";", "}", "}", "else", "{", "jude_size_t", "index", ";", "jude_size_t", "lhs_count", "=", "jude_get_array_count", "(", "lhs_iter", ".", "current_field", ",", "lhs_iter", ".", "details", ".", "data", ")", ";", "jude_size_t", "rhs_count", "=", "jude_get_array_count", "(", "rhs_iter", ".", "current_field", ",", "rhs_iter", ".", "details", ".", "data", ")", ";", "if", "(", "lhs_count", "<", "rhs_count", ")", "{", "return", "LhsLessThanRhs", ";", "}", "else", "if", "(", "lhs_count", ">", "rhs_count", ")", "{", "return", "LhsGreaterThanRhs", ";", "}", "for", "(", "index", "=", "0", ";", "index", "<", "lhs_count", ";", "index", "++", ")", "{", "jude_object_t", "*", "lhs_subresource", "=", "(", "jude_object_t", "*", ")", "jude_iterator_get_data", "(", "&", "lhs_iter", ",", "index", ")", ";", "jude_object_t", "*", "rhs_subresource", "=", "(", "jude_object_t", "*", ")", "jude_iterator_get_data", "(", "&", "rhs_iter", ",", "index", ")", ";", "result", "=", "jude_object_compare", "(", "lhs_subresource", ",", "rhs_subresource", ")", ";", "if", "(", "result", "!=", "0", ")", "{", "return", "result", ";", "}", "}", "}", "}", "else", "{", "jude_size_t", "lengthOfDataToCompare", "=", "lhs_iter", ".", "current_field", "->", "data_size", ";", "if", "(", "jude_iterator_is_array", "(", "&", "lhs_iter", ")", ")", "{", "jude_size_t", "lhs_count", "=", "jude_iterator_get_count", "(", "&", "lhs_iter", ")", ";", "jude_size_t", "rhs_count", "=", "jude_iterator_get_count", "(", "&", "rhs_iter", ")", ";", "if", "(", "lhs_count", "<", "rhs_count", ")", "{", "return", "LhsLessThanRhs", ";", "}", "else", "if", "(", "lhs_count", ">", "rhs_count", ")", "{", "return", "LhsGreaterThanRhs", ";", "}", "else", "{", "lengthOfDataToCompare", "=", "lhs_count", "*", "jude_field_get_size", "(", "lhs_iter", ".", "current_field", ")", ";", "}", "}", "result", "=", "memcmp", "(", "lhs_iter", ".", "details", ".", "data", ",", "rhs_iter", ".", "details", ".", "data", ",", "lengthOfDataToCompare", ")", ";", "if", "(", "result", "!=", "0", ")", "{", "return", "result", ";", "}", "}", "}", "while", "(", "jude_iterator_next", "(", "&", "lhs_iter", ")", "&&", "jude_iterator_next", "(", "&", "rhs_iter", ")", ")", ";", "return", "LhsEqualToRhs", ";", "}" ]

[ "Similar", "to", "memcmp", "but", "for", "messages", "." ]

[ "// trivial cases", "// iteratre through the fields, use recursion on submessages (and arrays of sub messages!)", "// neither field set, skip test", "// When comparing protobuf messages, we must treat submessages field in a special way", "// they contain dirty flags that may differ but that should not affect equality", "// Here, we recurse into each sub message (more complicated if it's an aray of submessages!)", "// Recurse into single sub message", "// Recurse into each sub message" ]

[ { "param": "lhs_struct", "type": "jude_object_t" }, { "param": "rhs_struct", "type": "jude_object_t" } ]

[ "MIT" ]

[ "Decode", "string", "length", "from", "stream", "and", "return", "a", "substream", "with", "limited", "length", ".", "Remember", "to", "close", "the", "substream", "using", "jude_close_context_substream", "()", "." ]

[ "static", "bool", "binary_context_substream_open", "(", "jude_context_type_t", "type", ",", "jude_istream_t", "*", "stream", ",", "jude_istream_t", "*", "substream", ")", "{", "switch", "(", "type", ")", "{", "case", "JUDE_CONTEXT_STRING", ":", "case", "JUDE_CONTEXT_DELIMITED", ":", "case", "JUDE_CONTEXT_REPEATED", ":", "case", "JUDE_CONTEXT_SUBMESSAGE", ":", "return", "jude_make_string_substream", "(", "stream", ",", "substream", ")", ";", "case", "JUDE_CONTEXT_MESSAGE", ":", "memcpy", "(", "substream", ",", "stream", ",", "sizeof", "(", "jude_istream_t", ")", ")", ";", "break", ";", "}", "return", "true", ";", "}" ]

[ "Decode", "string", "length", "from", "stream", "and", "return", "a", "substream", "with", "limited", "length", "." ]

[]

[ { "param": "type", "type": "jude_context_type_t" }, { "param": "stream", "type": "jude_istream_t" }, { "param": "substream", "type": "jude_istream_t" } ]

[ "MIT" ]

[ "Move", "to", "next", "element", "within", "a", "substream", "context", "-", "useful", "for", "traversing", "arrays", "in", "wiretypes", "like", "JSON" ]

[ "static", "bool", "binary_context_substream_next_element", "(", "jude_context_type_t", "type", ",", "jude_istream_t", "*", "substream", ")", "{", "if", "(", "type", "==", "JUDE_CONTEXT_DELIMITED", ")", "{", "}", "return", "true", ";", "}" ]

[ "Move", "to", "next", "element", "within", "a", "substream", "context", "-", "useful", "for", "traversing", "arrays", "in", "wiretypes", "like", "JSON" ]

[ "// delimited field stream..." ]

[ { "param": "type", "type": "jude_context_type_t" }, { "param": "substream", "type": "jude_istream_t" } ]

[ "MIT" ]

[ "Initialize", "message", "fields", "to", "default", "values", "recursively" ]

[ "static", "void", "jude_field_set_to_default", "(", "jude_iterator_t", "*", "iter", ")", "{", "jude_type_t", "type", "=", "iter", "->", "current_field", "->", "type", ";", "bool", "init_data", "=", "true", ";", "if", "(", "!", "jude_iterator_is_array", "(", "iter", ")", ")", "{", "jude_filter_set_touched", "(", "iter", "->", "object", "->", "__mask", ",", "iter", "->", "field_index", ",", "false", ")", ";", "}", "else", "{", "*", "(", "jude_size_t", "*", ")", "jude_iterator_get_count_reference", "(", "iter", ")", "=", "0", ";", "init_data", "=", "false", ";", "}", "if", "(", "init_data", ")", "{", "if", "(", "jude_field_is_object", "(", "iter", "->", "current_field", ")", ")", "{", "jude_message_set_to_defaults", "(", "iter", "->", "details", ".", "sub_object", ")", ";", "}", "else", "if", "(", "(", "iter", "->", "current_field", "->", "details", ".", "default_data", "!=", "NULL", ")", "&&", "(", "type", "!=", "JUDE_TYPE_ENUM", ")", ")", "{", "memcpy", "(", "iter", "->", "details", ".", "data", ",", "iter", "->", "current_field", "->", "details", ".", "default_data", ",", "iter", "->", "current_field", "->", "data_size", ")", ";", "}", "else", "{", "memset", "(", "iter", "->", "details", ".", "data", ",", "0", ",", "iter", "->", "current_field", "->", "data_size", ")", ";", "}", "}", "}" ]

[ "Initialize", "message", "fields", "to", "default", "values", "recursively" ]

[ "/* Set has_field to false. Still initialize the optional field itself also. */", "/* REPEATED: Set array count to 0, no need to initialize contents.*/", "/* Initialize submessage to defaults */", "/* Initialize to default value */", "/* Initialize to zeros */" ]

[ { "param": "iter", "type": "jude_iterator_t" } ]

[ "Apache-2.0" ]

[ "Place", "NB", "control", "block", "on", "the", "free", "list" ]

[ "static", "void", "gupcr_nbcb_free", "(", "gupcr_nbcb_p", "cb", ")", "{", "cb", "->", "next", "=", "gupcr_nbcb_cb_free", ";", "gupcr_nbcb_cb_free", "=", "cb", ";", "}" ]

[ "Place", "NB", "control", "block", "on", "the", "free", "list" ]

[]

[ { "param": "cb", "type": "gupcr_nbcb_p" } ]

[ "Apache-2.0" ]

[ "Place", "NB", "control", "block", "on", "the", "active", "list" ]

[ "static", "void", "gupcr_nbcb_active_insert", "(", "gupcr_nbcb_p", "cb", ")", "{", "cb", "->", "next", "=", "gupcr_nbcb_active", ";", "gupcr_nbcb_active", "=", "cb", ";", "}" ]

[ "Place", "NB", "control", "block", "on", "the", "active", "list" ]

[]

[ { "param": "cb", "type": "gupcr_nbcb_p" } ]

[ "Apache-2.0" ]

[ "Remove", "NB", "control", "block", "from", "the", "active", "list" ]

[ "static", "void", "gupcr_nbcb_active_remove", "(", "gupcr_nbcb_p", "cb", ")", "{", "gupcr_nbcb_p", "acb", "=", "gupcr_nbcb_active", ";", "gupcr_nbcb_p", "prev_acb", "=", "acb", ";", "while", "(", "acb", ")", "{", "if", "(", "acb", "==", "cb", ")", "{", "if", "(", "acb", "==", "gupcr_nbcb_active", ")", "gupcr_nbcb_active", "=", "acb", "->", "next", ";", "else", "prev_acb", "->", "next", "=", "acb", "->", "next", ";", "return", ";", "}", "prev_acb", "=", "acb", ";", "acb", "=", "acb", "->", "next", ";", "}", "}" ]

[ "Remove", "NB", "control", "block", "from", "the", "active", "list" ]

[]

[ { "param": "cb", "type": "gupcr_nbcb_p" } ]

[ "Apache-2.0" ]

[ "Find", "NB", "control", "block", "on", "the", "active", "list" ]

[ "static", "gupcr_nbcb_p", "gupcr_nbcb_find", "(", "unsigned", "long", "id", ")", "{", "gupcr_nbcb_p", "cb", "=", "gupcr_nbcb_active", ";", "while", "(", "cb", ")", "{", "if", "(", "cb", "->", "id", "==", "id", ")", "return", "cb", ";", "cb", "=", "cb", "->", "next", ";", "}", "return", "NULL", ";", "}" ]

[ "Find", "NB", "control", "block", "on", "the", "active", "list" ]

[]

[ { "param": "id", "type": "unsigned long" } ]

[ "Apache-2.0" ]

[ "Check", "for", "the", "max", "number", "of", "outstanding", "non", "-", "blocking", "transfers", "with", "explicit", "handle", "We", "cannot", "allow", "for", "number", "of", "outstanding", "transfers", "to", "go", "over", "the", "event", "queue", "size", ".", "Otherwise", "some", "ACK", "/", "REPLY", "can", "be", "dropped", "." ]

[ "void", "gupcr_nb_check_outstanding", "(", "void", ")", "{", "if", "(", "gupcr_nb_outstanding", "==", "GUPCR_NB_MAX_OUTSTANDING", ")", "{", "ptl_event_t", "event", ";", "gupcr_portals_call", "(", "PtlEQWait", ",", "(", "gupcr_nb_md_eq", ",", "&", "event", ")", ")", ";", "if", "(", "event", ".", "type", "==", "PTL_EVENT_ACK", "||", "event", ".", "type", "==", "PTL_EVENT_REPLY", ")", "{", "gupcr_nbcb_p", "cb", ";", "unsigned", "long", "id", "=", "(", "unsigned", "long", ")", "event", ".", "user_ptr", ";", "gupcr_debug", "(", "FC_NB", ",", "\"", "\"", ",", "id", ")", ";", "cb", "=", "gupcr_nbcb_find", "(", "id", ")", ";", "if", "(", "!", "cb", "||", "cb", "->", "status", "==", "NB_STATUS_COMPLETED", ")", "{", "gupcr_fatal_error", "(", "\"", "\"", "\"", "\"", ")", ";", "}", "cb", "->", "status", "=", "NB_STATUS_COMPLETED", ";", "gupcr_nb_outstanding", "--", ";", "}", "else", "{", "gupcr_fatal_error", "(", "\"", "\"", ",", "gupcr_streqtype", "(", "event", ".", "type", ")", ")", ";", "}", "}", "}" ]

[ "Check", "for", "the", "max", "number", "of", "outstanding", "non", "-", "blocking", "transfers", "with", "explicit", "handle" ]

[ "/* We have to wait for at least one to complete. */", "/* Process only ACKs and REPLYs, */" ]

[]

[ "Apache-2.0" ]

[ "Check", "for", "non", "-", "blocking", "transfer", "complete", "@param", "[", "in", "]", "handle", "Transfer", "handle", "@retval", "\"", "1", "\"", "if", "transfer", "completed" ]

[ "int", "gupcr_nb_completed", "(", "unsigned", "long", "handle", ")", "{", "ptl_event_t", "event", ";", "int", "done", "=", "0", ";", "gupcr_nbcb_p", "cb", ";", "while", "(", "!", "done", ")", "{", "int", "pstatus", ";", "gupcr_portals_call_with_status", "(", "PtlEQGet", ",", "pstatus", ",", "(", "gupcr_nb_md_eq", ",", "&", "event", ")", ")", ";", "if", "(", "pstatus", "==", "PTL_OK", ")", "{", "if", "(", "event", ".", "type", "==", "PTL_EVENT_ACK", "||", "event", ".", "type", "==", "PTL_EVENT_REPLY", ")", "{", "unsigned", "long", "id", "=", "(", "unsigned", "long", ")", "event", ".", "user_ptr", ";", "gupcr_debug", "(", "FC_NB", ",", "\"", "\"", ",", "id", ")", ";", "cb", "=", "gupcr_nbcb_find", "(", "id", ")", ";", "if", "(", "!", "cb", ")", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "cb", "->", "status", "=", "NB_STATUS_COMPLETED", ";", "gupcr_nb_outstanding", "--", ";", "}", "else", "{", "gupcr_fatal_error", "(", "\"", "\"", ",", "gupcr_streqtype", "(", "event", ".", "type", ")", ")", ";", "}", "}", "else", "done", "=", "1", ";", "}", "cb", "=", "gupcr_nbcb_find", "(", "handle", ")", ";", "if", "(", "cb", "&&", "cb", "->", "status", "==", "NB_STATUS_COMPLETED", ")", "{", "gupcr_nbcb_active_remove", "(", "cb", ")", ";", "gupcr_nbcb_free", "(", "cb", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}" ]

[ "Check", "for", "non", "-", "blocking", "transfer", "complete", "@param", "[", "in", "]", "handle", "Transfer", "handle", "@retval", "\"", "1", "\"", "if", "transfer", "completed" ]

[ "/* Handle Portals completion events. */", "/* There is something to process. */", "/* Check if transfer is completed. */" ]

[ { "param": "handle", "type": "unsigned long" } ]

[ "Apache-2.0" ]

[ "Complete", "non", "-", "blocking", "transfers", "with", "explicit", "handle", "Wait", "for", "outstanding", "request", "to", "complete", ".", "@param", "[", "in", "]", "handle", "Transfer", "handle" ]

[ "void", "gupcr_sync", "(", "unsigned", "long", "handle", ")", "{", "gupcr_nbcb_p", "cb", ";", "gupcr_debug", "(", "FC_NB", ",", "\"", "\"", ",", "handle", ")", ";", "cb", "=", "gupcr_nbcb_find", "(", "handle", ")", ";", "if", "(", "!", "cb", ")", "{", "return", ";", "}", "if", "(", "cb", "->", "status", "==", "NB_STATUS_COMPLETED", ")", "{", "gupcr_nbcb_active_remove", "(", "cb", ")", ";", "gupcr_nbcb_free", "(", "cb", ")", ";", "}", "else", "{", "int", "done", "=", "0", ";", "while", "(", "!", "done", ")", "{", "ptl_event_t", "event", ";", "int", "pstatus", ";", "gupcr_portals_call_with_status", "(", "PtlEQGet", ",", "pstatus", ",", "(", "gupcr_nb_md_eq", ",", "&", "event", ")", ")", ";", "if", "(", "pstatus", "==", "PTL_OK", ")", "{", "gupcr_debug", "(", "FC_NB", ",", "\"", "\"", ",", "gupcr_streqtype", "(", "event", ".", "type", ")", ")", ";", "if", "(", "event", ".", "type", "==", "PTL_EVENT_ACK", "||", "event", ".", "type", "==", "PTL_EVENT_REPLY", ")", "{", "unsigned", "long", "id", "=", "(", "unsigned", "long", ")", "event", ".", "user_ptr", ";", "gupcr_debug", "(", "FC_NB", ",", "\"", "\"", ",", "id", ")", ";", "cb", "=", "gupcr_nbcb_find", "(", "id", ")", ";", "if", "(", "!", "cb", "||", "cb", "->", "status", "==", "NB_STATUS_COMPLETED", ")", "{", "gupcr_fatal_error", "(", "\"", "\"", "\"", "\"", ")", ";", "}", "cb", "->", "status", "=", "NB_STATUS_COMPLETED", ";", "gupcr_nb_outstanding", "--", ";", "if", "(", "id", "==", "handle", ")", "{", "gupcr_nbcb_active_remove", "(", "cb", ")", ";", "gupcr_nbcb_free", "(", "cb", ")", ";", "done", "=", "1", ";", "}", "}", "else", "{", "gupcr_fatal_error", "(", "\"", "\"", ",", "gupcr_streqtype", "(", "event", ".", "type", ")", ")", ";", "}", "}", "}", "}", "}" ]

[ "Complete", "non", "-", "blocking", "transfers", "with", "explicit", "handle", "Wait", "for", "outstanding", "request", "to", "complete", "." ]

[ "/* Check if transfer already completed. */", "/* Handle does not exist. Assume it is a duplicate\n sync request. */", "/* Already completed. */", "/* Must wait for portals to complete the transfer. */", "/* Process only ACKs and REPLYs, */" ]

[ { "param": "handle", "type": "unsigned long" } ]

[ "Apache-2.0" ]

[ "Check", "for", "any", "outstanding", "implicit", "handle", "non", "-", "blocking", "transfer", "@retval", "Number", "of", "outstanding", "transfers" ]

[ "int", "gupcr_nbi_outstanding", "(", "void", ")", "{", "ptl_ct_event_t", "ct", ";", "gupcr_portals_call", "(", "PtlCTGet", ",", "(", "gupcr_nbi_md_ct", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_nbi_md_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "return", "(", "int", ")", "(", "gupcr_nbi_md_count", "-", "ct", ".", "success", ")", ";", "}" ]

[ "Check", "for", "any", "outstanding", "implicit", "handle", "non", "-", "blocking", "transfer", "@retval", "Number", "of", "outstanding", "transfers" ]

[ "/* Check the number of completed transfers. */" ]

[]

[ "Apache-2.0" ]

[ "Initialize", "non", "-", "blocking", "transfer", "resources", "@ingroup", "INIT" ]

[ "void", "gupcr_nb_init", "(", "void", ")", "{", "ptl_md_t", "md", ";", "ptl_pt_index_t", "pte", ";", "ptl_le_t", "le", ";", "gupcr_log", "(", "FC_NB", ",", "\"", "\"", ")", ";", "gupcr_portals_call", "(", "PtlPTAlloc", ",", "(", "gupcr_ptl_ni", ",", "0", ",", "PTL_EQ_NONE", ",", "GUPCR_PTL_PTE_NB", ",", "&", "pte", ")", ")", ";", "if", "(", "pte", "!=", "GUPCR_PTL_PTE_NB", ")", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "gupcr_debug", "(", "FC_NB", ",", "\"", "\"", ",", "GUPCR_PTL_PTE_NB", ")", ";", "le", ".", "start", "=", "gupcr_gmem_base", ";", "le", ".", "length", "=", "gupcr_gmem_size", ";", "le", ".", "ct_handle", "=", "PTL_CT_NONE", ";", "le", ".", "uid", "=", "PTL_UID_ANY", ";", "le", ".", "options", "=", "PTL_LE_OP_PUT", "|", "PTL_LE_OP_GET", ";", "gupcr_portals_call", "(", "PtlLEAppend", ",", "(", "gupcr_ptl_ni", ",", "GUPCR_PTL_PTE_NB", ",", "&", "le", ",", "PTL_PRIORITY_LIST", ",", "NULL", ",", "&", "gupcr_nb_le", ")", ")", ";", "gupcr_debug", "(", "FC_NB", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "gupcr_gmem_base", ",", "(", "long", "unsigned", ")", "gupcr_gmem_size", ")", ";", "gupcr_portals_call", "(", "PtlEQAlloc", ",", "(", "gupcr_ptl_ni", ",", "GUPCR_NB_MAX_OUTSTANDING", ",", "&", "gupcr_nb_md_eq", ")", ")", ";", "md", ".", "length", "=", "(", "ptl_size_t", ")", "USER_PROG_MEM_SIZE", ";", "md", ".", "start", "=", "(", "void", "*", ")", "USER_PROG_MEM_START", ";", "md", ".", "options", "=", "PTL_MD_EVENT_SEND_DISABLE", ";", "md", ".", "eq_handle", "=", "gupcr_nb_md_eq", ";", "md", ".", "ct_handle", "=", "PTL_CT_NONE", ";", "gupcr_portals_call", "(", "PtlMDBind", ",", "(", "gupcr_ptl_ni", ",", "&", "md", ",", "&", "gupcr_nb_md", ")", ")", ";", "gupcr_nb_md_start", "=", "md", ".", "start", ";", "gupcr_portals_call", "(", "PtlEQAlloc", ",", "(", "gupcr_ptl_ni", ",", "1", ",", "&", "gupcr_nbi_md_eq", ")", ")", ";", "gupcr_portals_call", "(", "PtlCTAlloc", ",", "(", "gupcr_ptl_ni", ",", "&", "gupcr_nbi_md_ct", ")", ")", ";", "md", ".", "length", "=", "(", "ptl_size_t", ")", "USER_PROG_MEM_SIZE", ";", "md", ".", "start", "=", "(", "void", "*", ")", "USER_PROG_MEM_START", ";", "md", ".", "options", "=", "PTL_MD_EVENT_CT_ACK", "|", "PTL_MD_EVENT_CT_REPLY", "|", "PTL_MD_EVENT_SUCCESS_DISABLE", ";", "md", ".", "eq_handle", "=", "gupcr_nbi_md_eq", ";", "md", ".", "ct_handle", "=", "gupcr_nbi_md_ct", ";", "gupcr_portals_call", "(", "PtlMDBind", ",", "(", "gupcr_ptl_ni", ",", "&", "md", ",", "&", "gupcr_nbi_md", ")", ")", ";", "gupcr_nbi_md_start", "=", "md", ".", "start", ";", "gupcr_nbi_md_count", "=", "0", ";", "gupcr_nb_handle_next", "=", "1", ";", "gupcr_nb_outstanding", "=", "0", ";", "}" ]

[ "Initialize", "non", "-", "blocking", "transfer", "resources", "@ingroup", "INIT" ]

[ "/* Non-blocking transfers use their own PTE. */", "/* Allocate LE for non-blocking transfers. */", "/* Setup the Portals MD for local source/destination copying.\n We need to map the whole user's space (same as gmem). */", "/* Non-blocking transfers with explicit handles must use full events\n there is no need for counting events. */", "/* Non-blocking transfers with implicit handles use counting events. */", "/* Reset number of acknowledgments. */", "/* Initialize NB handle values. */", "/* Initialize number of outstanding transfers. */" ]

[]

[ "Apache-2.0" ]

[ "Release", "non", "-", "blocking", "transfer", "resources", "@ingroup", "INIT" ]

[ "void", "gupcr_nb_fini", "(", "void", ")", "{", "gupcr_log", "(", "FC_NB", ",", "\"", "\"", ")", ";", "gupcr_portals_call", "(", "PtlMDRelease", ",", "(", "gupcr_nb_md", ")", ")", ";", "gupcr_portals_call", "(", "PtlEQFree", ",", "(", "gupcr_nb_md_eq", ")", ")", ";", "gupcr_portals_call", "(", "PtlMDRelease", ",", "(", "gupcr_nbi_md", ")", ")", ";", "gupcr_portals_call", "(", "PtlEQFree", ",", "(", "gupcr_nbi_md_eq", ")", ")", ";", "gupcr_portals_call", "(", "PtlCTFree", ",", "(", "gupcr_nbi_md_ct", ")", ")", ";", "gupcr_portals_call", "(", "PtlLEUnlink", ",", "(", "gupcr_nb_le", ")", ")", ";", "gupcr_portals_call", "(", "PtlPTFree", ",", "(", "gupcr_ptl_ni", ",", "GUPCR_PTL_PTE_NB", ")", ")", ";", "}" ]

[ "Release", "non", "-", "blocking", "transfer", "resources", "@ingroup", "INIT" ]

[ "/* Release explicit handle NB MD and its resources. */", "/* Release implicit handle NB MD and its resources. */", "/* Release LE and PTE. */" ]

[]

[ "Apache-2.0" ]

[ "This", "procedure", "sets", "the", "necessary", "Portals", "triggers", "to", "implement", "the", "pass", "that", "derives", "a", "consensus", "barrier", "ID", "value", "across", "all", "UPC", "threads", ".", "The", "inner", "threads", "use", "Portals", "triggered", "operations", "to", "pass", "the", "barrier", "ID", "negotiated", "among", "itself", "and", "its", "children", "up", "the", "tree", "its", "parent", ".", "@param", "[", "in", "]", "barrier_id", "Barrier", "ID" ]

[ "void", "__upc_notify", "(", "int", "barrier_id", ")", "{", "ptl_process_t", "rpid", "", "__attribute", "(", "(", "unused", ")", ")", ";", "GUPCR_OMP_CHECK", "(", ")", ";", "gupcr_trace", "(", "FC_BARRIER", ",", "\"", "\"", ",", "barrier_id", ")", ";", "if", "(", "gupcr_barrier_active", ")", "gupcr_error", "(", "\"", "\"", "\"", "\"", ")", ";", "gupcr_barrier_active", "=", "1", ";", "gupcr_barrier_id", "=", "barrier_id", ";", "gupcr_gmem_sync", "(", ")", ";", "#if", "GUPCR_USE_PORTALS4_TRIGGERED_OPS", "\n", "if", "(", "THREADS", "==", "1", ")", "return", ";", "gupcr_barrier_value", "=", "(", "barrier_id", "==", "BARRIER_ANONYMOUS", ")", "?", "BARRIER_ID_MAX", ":", "barrier_id", ";", "if", "(", "gupcr_debug_enabled", "(", "FC_BARRIER", ")", ")", "{", "ptl_ct_event_t", "ct", ";", "gupcr_portals_call", "(", "PtlCTGet", ",", "(", "gupcr_wait_le_ct", ",", "&", "ct", ")", ")", ";", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "ct", ".", "success", ",", "(", "long", "unsigned", ")", "gupcr_wait_le_count", ")", ";", "gupcr_portals_call", "(", "PtlCTGet", ",", "(", "gupcr_wait_md_ct", ",", "&", "ct", ")", ")", ";", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "ct", ".", "success", ",", "(", "long", "unsigned", ")", "gupcr_wait_md_count", ")", ";", "gupcr_portals_call", "(", "PtlCTGet", ",", "(", "gupcr_notify_le_ct", ",", "&", "ct", ")", ")", ";", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "ct", ".", "success", ",", "(", "long", "unsigned", ")", "gupcr_notify_le_count", ")", ";", "gupcr_portals_call", "(", "PtlCTGet", ",", "(", "gupcr_notify_md_ct", ",", "&", "ct", ")", ")", ";", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "ct", ".", "success", ",", "(", "long", "unsigned", ")", "gupcr_notify_md_count", ")", ";", "gupcr_portals_call", "(", "PtlCTGet", ",", "(", "gupcr_barrier_md_ct", ",", "&", "ct", ")", ")", ";", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "ct", ".", "success", ",", "(", "long", "unsigned", ")", "gupcr_barrier_md_count", ")", ";", "gupcr_portals_call", "(", "PtlCTGet", ",", "(", "gupcr_barrier_max_md_ct", ",", "&", "ct", ")", ")", ";", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "ct", ".", "success", ",", "(", "long", "unsigned", ")", "gupcr_barrier_max_md_count", ")", ";", "}", "if", "(", "LEAF_THREAD", ")", "{", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "gupcr_barrier_value", ",", "gupcr_parent_thread", ")", ";", "rpid", ".", "rank", "=", "gupcr_parent_thread", ";", "gupcr_portals_call", "(", "PtlAtomic", ",", "(", "gupcr_barrier_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "PTL_MIN", ",", "PTL_INT32_T", ")", ")", ";", "}", "else", "{", "int", "i", ";", "if", "(", "ROOT_THREAD", ")", "{", "rpid", ".", "rank", "=", "MYTHREAD", ";", "gupcr_notify_le_count", "+=", "gupcr_child_cnt", "+", "1", ";", "gupcr_portals_call", "(", "PtlTriggeredPut", ",", "(", "gupcr_notify_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_DOWN", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "gupcr_notify_le_ct", ",", "gupcr_notify_le_count", ")", ")", ";", "}", "else", "{", "rpid", ".", "rank", "=", "gupcr_parent_thread", ";", "gupcr_notify_le_count", "+=", "gupcr_child_cnt", "+", "1", ";", "gupcr_portals_call", "(", "PtlTriggeredAtomic", ",", "(", "gupcr_notify_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "PTL_MIN", ",", "PTL_INT32_T", ",", "gupcr_notify_le_ct", ",", "gupcr_notify_le_count", ")", ")", ";", "}", "rpid", ".", "rank", "=", "MYTHREAD", ";", "gupcr_wait_le_count", "+=", "1", ";", "gupcr_portals_call", "(", "PtlTriggeredPut", ",", "(", "gupcr_barrier_max_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "gupcr_wait_le_ct", ",", "gupcr_wait_le_count", ")", ")", ";", "gupcr_notify_le_count", "+=", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "gupcr_child_cnt", ";", "i", "++", ")", "{", "rpid", ".", "rank", "=", "gupcr_child", "[", "i", "]", ";", "gupcr_portals_call", "(", "PtlTriggeredPut", ",", "(", "gupcr_wait_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_OC_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_DOWN", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "gupcr_notify_le_ct", ",", "gupcr_notify_le_count", ")", ")", ";", "}", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "gupcr_barrier_value", ",", "MYTHREAD", ")", ";", "rpid", ".", "rank", "=", "MYTHREAD", ";", "gupcr_portals_call", "(", "PtlAtomic", ",", "(", "gupcr_barrier_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "PTL_MIN", ",", "PTL_INT32_T", ")", ")", ";", "}", "#else", "#endif", "gupcr_trace", "(", "FC_BARRIER", ",", "\"", "\"", ",", "barrier_id", ")", ";", "}" ]

[ "@fn", "__upc_notify", "(", "int", "barrier_id", ")", "UPC", "<i", ">", "upc_notify<i", ">", "statement", "implementation" ]

[ "/* The UPC shared memory consistency model requires all outstanding\n read/write operations to complete on the thread's\n current synchronization phase. */", "/* Use barrier MAX number if barrier ID is \"match all\"\n This effectively excludes the thread from setting the min ID\n among the threads. */", "/* Send the barrier ID to the parent - use atomic PTL_MIN to allow\n parent to find the minimum barrier ID among itself and its\n children. */", "/* The consensus MIN barrier ID derived in the notify (UP) phase\n\t must be transferred to the wait LE for delivery to all children.\n\t Trigger: Barrier ID received in the notify phase.\n\t Action: Send the barrier ID to the wait buffer of the\n\t barrier DOWN LE. */", "/* The consensus MIN barrier ID of the inner thread and its children\n\t is sent to the parent UPC thread.\n\t Trigger: All children and this thread execute an atomic PTL_MIN\n\t using each thread's UP LE.\n\t Action: Transfer the consensus minimum barrier ID to the\n\t this thread's parent. */", "/* Trigger: Barrier ID received in the wait buffer.\n Action: Reinitialize the barrier UP ID to barrier MAX value\n for the next call to upc_notify. */", "/* Trigger: The barrier ID is reinitialized to MAX.\n Action: Send the consensus barrier ID to all children. */", "/* Allow notify to proceed and to possibly complete the wait\n phase on other threads. */", "/* Find the minimum barrier ID among children and the root. */", "/* The UPC runtime barrier implementation that does not use\n Portals triggered operations does not support split phase barriers.\n In this case, all Portals actions related to the barrier\n are performed in the __upc_wait() function. */" ]

[ { "param": "barrier_id", "type": "int" } ]

[ "Apache-2.0" ]

[ "This", "procedure", "waits", "to", "receive", "the", "derived", "consensus", "barrier", "ID", "from", "the", "parent", "(", "leaf", "thread", ")", "or", "acknowledges", "that", "all", "children", "received", "the", "consensus", "barrier", "ID", "(", "inner", "and", "root", "threads", ")", ".", "The", "consensus", "barrier", "ID", "is", "checked", "against", "the", "barrier", "ID", "passed", "in", "as", "an", "argument", ".", "@param", "[", "in", "]", "barrier_id", "Barrier", "ID" ]

[ "void", "__upc_wait", "(", "int", "barrier_id", ")", "{", "ptl_ct_event_t", "ct", ";", "ptl_process_t", "rpid", "", "__attribute", "(", "(", "unused", ")", ")", ";", "int", "received_barrier_id", ";", "GUPCR_OMP_CHECK", "(", ")", ";", "gupcr_trace", "(", "FC_BARRIER", ",", "\"", "\"", ",", "barrier_id", ")", ";", "if", "(", "!", "gupcr_barrier_active", ")", "gupcr_error", "(", "\"", "\"", "\"", "\"", ")", ";", "if", "(", "(", "barrier_id", "!=", "BARRIER_ANONYMOUS", "&&", "gupcr_barrier_id", "!=", "BARRIER_ANONYMOUS", ")", "&&", "(", "gupcr_barrier_id", "!=", "barrier_id", ")", ")", "{", "gupcr_error", "(", "\"", "\"", ",", "gupcr_barrier_id", ",", "barrier_id", ")", ";", "}", "if", "(", "THREADS", "==", "1", ")", "{", "gupcr_barrier_active", "=", "0", ";", "return", ";", "}", "#if", "GUPCR_USE_PORTALS4_TRIGGERED_OPS", "\n", "if", "(", "gupcr_child_cnt", ")", "{", "gupcr_wait_md_count", "+=", "gupcr_child_cnt", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_md_ct", ",", "gupcr_wait_md_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_md_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "}", "else", "{", "gupcr_wait_le_count", "+=", "1", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_le_ct", ",", "gupcr_wait_le_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_le_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "}", "received_barrier_id", "=", "*", "gupcr_wait_ptr", ";", "#else", "gupcr_barrier_value", "=", "(", "barrier_id", "==", "BARRIER_ANONYMOUS", ")", "?", "BARRIER_ID_MAX", ":", "barrier_id", ";", "if", "(", "!", "LEAF_THREAD", ")", "{", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "gupcr_barrier_value", ",", "MYTHREAD", ")", ";", "rpid", ".", "rank", "=", "MYTHREAD", ";", "gupcr_portals_call", "(", "PtlAtomic", ",", "(", "gupcr_barrier_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "PTL_MIN", ",", "PTL_INT32_T", ")", ")", ";", "gupcr_notify_le_count", "+=", "gupcr_child_cnt", "+", "1", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_notify_le_ct", ",", "gupcr_notify_le_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_notify_le_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "}", "if", "(", "!", "ROOT_THREAD", ")", "{", "ptl_handle_md_t", "source_md", ";", "gupcr_debug", "(", "FC_BARRIER", ",", "\"", "\"", ",", "gupcr_barrier_value", ",", "gupcr_parent_thread", ")", ";", "if", "(", "LEAF_THREAD", ")", "source_md", "=", "gupcr_barrier_md", ";", "else", "source_md", "=", "gupcr_notify_md", ";", "rpid", ".", "rank", "=", "gupcr_parent_thread", ";", "gupcr_portals_call", "(", "PtlAtomic", ",", "(", "source_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "PTL_MIN", ",", "PTL_INT32_T", ")", ")", ";", "}", "if", "(", "ROOT_THREAD", ")", "{", "*", "(", "int", "*", ")", "gupcr_wait_ptr", "=", "gupcr_notify_value", ";", "}", "else", "{", "gupcr_wait_le_count", "+=", "1", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_le_ct", ",", "gupcr_wait_le_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_le_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "}", "received_barrier_id", "=", "gupcr_notify_value", ";", "if", "(", "!", "LEAF_THREAD", ")", "{", "int", "i", ";", "gupcr_notify_value", "=", "BARRIER_ID_MAX", ";", "for", "(", "i", "=", "0", ";", "i", "<", "gupcr_child_cnt", ";", "i", "++", ")", "{", "rpid", ".", "rank", "=", "gupcr_child", "[", "i", "]", ";", "gupcr_portals_call", "(", "PtlPut", ",", "(", "gupcr_wait_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_OC_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_DOWN", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ")", ")", ";", "}", "gupcr_wait_md_count", "+=", "gupcr_child_cnt", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_md_ct", ",", "gupcr_wait_md_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_md_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "}", "#endif", "if", "(", "barrier_id", "!=", "INT_MIN", "&&", "barrier_id", "!=", "received_barrier_id", "&&", "received_barrier_id", "!=", "BARRIER_ID_MAX", ")", "gupcr_error", "(", "\"", "\"", "\"", "\"", ",", "MYTHREAD", ",", "barrier_id", ",", "received_barrier_id", ")", ";", "gupcr_gmem_sync", "(", ")", ";", "gupcr_barrier_active", "=", "0", ";", "gupcr_trace", "(", "FC_BARRIER", ",", "\"", "\"", ",", "barrier_id", ")", ";", "}" ]

[ "@fn", "__upc_wait", "(", "int", "barrier_id", ")", "UPC", "<i", ">", "upc_wait<", "/", "i", ">", "statement", "implementation" ]

[ "/* Check if notify/wait barrier IDs match.\n BARRIER_ANONYMOUS matches any other barrier ID. */", "/* Wait for the barrier ID to propagate down the tree. */", "/* Wait for the barrier ID to flow down to the children. */", "/* UPC Barrier implementation without Portals Triggered Functions. */", "/* NOTIFY - Propagate minimal barrier ID to the root thread. */", "/* Use the barrier maximum ID number if the barrier ID is \"match all\".\n This effectively excludes the thread from setting the minimum ID\n among the threads. */", "/* This step is performed by the root thread and inner threads. */", "/* Find the minimal barrier ID among the thread and children.\n Use the Portals PTL_MIN atomic operation on the value\n\t in the notify LE. */", "/* Wait for all children threads to report their barrier IDs.\n Account for this thread's atomic PTL_MIN. */", "/* This step is performed by leaf threads and inner threads. */", "/* Send the barrier ID to the parent - use atomic PTL_MIN on the value\n in the parents notify LE (derived minimal ID for the parent and its\n children. */", "/* An inner thread uses the minimal barrier ID\n\t derived from the parent thread and all its children. */", "/* At this point, the derived minimal barrier ID among all threads\n has arrived at the root thread. */", "/* Wait for the parent to send the derived agreed on barrier ID. */", "/* An inner thread sends the derived consensus\n minimum barrier ID to its children. */", "/* Re-initialize the barrier ID maximum range value. */", "/* Send the derived consensus minimum barrier ID to\n this thread's children. */", "/* Wait until all children receive the consensus minimum\n barrier ID that is propagated down the tree. */", "/* GUPCR_USE_PORTALS4_TRIGGERED_OPS */", "/* Verify that the barrier ID matches. */", "/* UPC Shared Memory Consistency Model requires all outstanding\n read/write operations to complete on the thread's enter\n into the next synchronization phase. */" ]

[ { "param": "barrier_id", "type": "int" } ]

[ "Apache-2.0" ]

[ "@fn", "gupcr_bcast_send", "(", "void", "*", "value", "size_t", "nbytes", ")", "Send", "broadcast", "message", "to", "all", "thread", "'", "s", "children", ".", "The", "broadcast", "is", "a", "collective", "operation", "where", "thread", "0", "(", "root", "thread", ")", "sends", "a", "message", "to", "all", "other", "threads", ".", "This", "function", "must", "be", "called", "by", "the", "thread", "0", "only", "from", "a", "public", "function", "\"", "gupcr_broadcast_put", "\"", ".", "@param", "[", "in", "]", "value", "Pointer", "to", "send", "value", "@param", "[", "in", "]", "nbytes", "Number", "of", "bytes", "to", "send", "@ingroup", "BROADCAST" ]

[ "void", "gupcr_bcast_send", "(", "void", "*", "value", ",", "size_t", "nbytes", ")", "{", "int", "i", ";", "ptl_process_t", "rpid", ";", "ptl_ct_event_t", "ct", ";", "gupcr_trace", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "value", ",", "(", "long", "unsigned", ")", "nbytes", ")", ";", "gupcr_gmem_sync", "(", ")", ";", "memcpy", "(", "gupcr_wait_ptr", ",", "value", ",", "nbytes", ")", ";", "gupcr_notify_le_count", "+=", "gupcr_child_cnt", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_notify_le_ct", ",", "gupcr_notify_le_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_notify_le_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "gupcr_child_cnt", ";", "i", "++", ")", "{", "rpid", ".", "rank", "=", "gupcr_child", "[", "i", "]", ";", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "gupcr_child", "[", "i", "]", ")", ";", "gupcr_portals_call", "(", "PtlPut", ",", "(", "gupcr_wait_md", ",", "0", ",", "nbytes", ",", "PTL_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_DOWN", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ")", ")", ";", "}", "gupcr_wait_md_count", "+=", "gupcr_child_cnt", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_md_ct", ",", "gupcr_wait_md_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_md_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "gupcr_trace", "(", "FC_BROADCAST", ",", "\"", "\"", ")", ";", "}" ]

[ "@fn", "gupcr_bcast_send", "(", "void", "*", "value", "size_t", "nbytes", ")", "Send", "broadcast", "message", "to", "all", "thread", "'", "s", "children", "." ]

[ "/* This broadcast operation is implemented a collective operation.\n Before proceeding, complete all outstanding shared memory\n read/write operations. */", "/* Copy the message into the buffer used for delivery\n to the children threads. */", "/* Send broadcast to this thread's children. */", "/* Wait for message delivery to all children. This ensures that\n the source buffer is not overwritten by back-to-back\n broadcast operations. */" ]

[ { "param": "value", "type": "void" }, { "param": "nbytes", "type": "size_t" } ]

[ "Apache-2.0" ]

[ "@fn", "gupcr_bcast_recv", "(", "void", "*", "value", "size_t", "nbytes", ")", "Wait", "to", "receive", "the", "broadcast", "message", "and", "return", "its", "value", ".", "Broadcast", "is", "a", "collective", "operation", "where", "thread", "0", "(", "the", "root", "thread", ")", "sends", "a", "message", "to", "all", "other", "threads", ".", "This", "function", "must", "be", "called", "by", "every", "thread", "other", "then", "thread", "0", ".", "@param", "[", "in", "]", "value", "Pointer", "to", "received", "value", "@param", "[", "in", "]", "nbytes", "Number", "of", "bytes", "to", "receive", "@ingroup", "BROADCAST" ]

[ "void", "gupcr_bcast_recv", "(", "void", "*", "value", ",", "size_t", "nbytes", ")", "{", "int", "i", ";", "ptl_process_t", "rpid", ";", "ptl_ct_event_t", "ct", ";", "gupcr_trace", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "value", ",", "(", "long", "unsigned", ")", "nbytes", ")", ";", "gupcr_gmem_sync", "(", ")", ";", "#if", "GUPCR_USE_PORTALS4_TRIGGERED_OPS", "\n", "if", "(", "INNER_THREAD", ")", "{", "gupcr_wait_le_count", "+=", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "gupcr_child_cnt", ";", "i", "++", ")", "{", "rpid", ".", "rank", "=", "gupcr_child", "[", "i", "]", ";", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "gupcr_child", "[", "i", "]", ")", ";", "gupcr_portals_call", "(", "PtlTriggeredPut", ",", "(", "gupcr_wait_md", ",", "0", ",", "nbytes", ",", "PTL_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_DOWN", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "gupcr_wait_le_ct", ",", "gupcr_wait_le_count", ")", ")", ";", "}", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "gupcr_parent_thread", ")", ";", "rpid", ".", "rank", "=", "gupcr_parent_thread", ";", "gupcr_barrier_value", "=", "BARRIER_ID_MAX", ";", "gupcr_notify_le_count", "+=", "gupcr_child_cnt", ";", "gupcr_portals_call", "(", "PtlTriggeredPut", ",", "(", "gupcr_barrier_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ",", "gupcr_notify_le_ct", ",", "gupcr_notify_le_count", ")", ")", ";", "gupcr_wait_md_count", "+=", "gupcr_child_cnt", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_md_ct", ",", "gupcr_wait_md_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_md_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "ct", ".", "success", ")", ";", "}", "else", "{", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "gupcr_parent_thread", ")", ";", "rpid", ".", "rank", "=", "gupcr_parent_thread", ";", "gupcr_barrier_value", "=", "BARRIER_ID_MAX", ";", "gupcr_portals_call", "(", "PtlPut", ",", "(", "gupcr_barrier_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ")", ")", ";", "gupcr_wait_le_count", "+=", "1", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_le_ct", ",", "gupcr_wait_le_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_le_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "}", "memcpy", "(", "value", ",", "gupcr_wait_ptr", ",", "nbytes", ")", ";", "#else", "if", "(", "INNER_THREAD", ")", "{", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "gupcr_child_cnt", ")", ";", "gupcr_notify_le_count", "+=", "gupcr_child_cnt", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_notify_le_ct", ",", "gupcr_child_cnt", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_notify_le_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "ct", ".", "success", ")", ";", "}", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "gupcr_parent_thread", ")", ";", "rpid", ".", "rank", "=", "gupcr_parent_thread", ";", "gupcr_barrier_value", "=", "BARRIER_ID_MAX", ";", "gupcr_portals_call", "(", "PtlPut", ",", "(", "gupcr_barrier_md", ",", "0", ",", "BARRIER_ID_SIZE", ",", "PTL_NO_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_UP", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ")", ")", ";", "gupcr_wait_le_count", "+=", "1", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_le_ct", ",", "gupcr_wait_le_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_le_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "memcpy", "(", "value", ",", "gupcr_wait_ptr", ",", "nbytes", ")", ";", "if", "(", "INNER_THREAD", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "gupcr_child_cnt", ";", "i", "++", ")", "{", "gupcr_debug", "(", "FC_BROADCAST", ",", "\"", "\"", ",", "gupcr_child", "[", "i", "]", ")", ";", "rpid", ".", "rank", "=", "gupcr_child", "[", "i", "]", ";", "gupcr_portals_call", "(", "PtlPut", ",", "(", "gupcr_wait_md", ",", "0", ",", "nbytes", ",", "PTL_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_BARRIER_DOWN", ",", "PTL_NO_MATCH_BITS", ",", "0", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ")", ")", ";", "}", "gupcr_wait_md_count", "+=", "gupcr_child_cnt", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_wait_md_ct", ",", "gupcr_wait_md_count", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ")", "{", "gupcr_process_fail_events", "(", "gupcr_wait_md_eq", ")", ";", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "}", "}", "#endif", "gupcr_trace", "(", "FC_BROADCAST", ",", "\"", "\"", ")", ";", "}" ]

[ "@fn", "gupcr_bcast_recv", "(", "void", "*", "value", "size_t", "nbytes", ")", "Wait", "to", "receive", "the", "broadcast", "message", "and", "return", "its", "value", "." ]

[ "/* Prepare triggers for message push to all children. */", "/* Trigger: message received from the parent.\n\t Action: send the message to the child. */", "/* Prepare a trigger to send notification to the parent. */", "/* Trigger: notification received from all children.\n Action: send notification to the parent. */", "/* Wait for delivery to all children. */", "/* A leaf thread sends notification to its parent that\n it is ready to receive the broadcast value. */", "/* Wait to receive a message from the parent. */", "/* Inner threads must wait for its children threads to arrive. */", "/* Inform the parent that this thread and all its children arrived.\n Send barrier MAX value as we share PTEs with the barrier\n implementation. */", "/* Receive the broadcast message from the parent. */", "/* Copy the received message. */", "/* An inner thread must pass the message to its children. */", "/* Wait for delivery to all children. */" ]

[ { "param": "value", "type": "void" }, { "param": "nbytes", "type": "size_t" } ]

[ "Apache-2.0" ]

[ "Initialize", "atomics", "resources", ".", "@ingroup", "INIT" ]

[ "void", "gupcr_atomic_init", "(", "void", ")", "{", "ptl_md_t", "md", ";", "gupcr_log", "(", "FC_ATOMIC", ",", "\"", "\"", ")", ";", "gupcr_portals_call", "(", "PtlCTAlloc", ",", "(", "gupcr_ptl_ni", ",", "&", "gupcr_atomic_md_ct", ")", ")", ";", "gupcr_portals_call", "(", "PtlEQAlloc", ",", "(", "gupcr_ptl_ni", ",", "1", ",", "&", "gupcr_atomic_md_eq", ")", ")", ";", "md", ".", "length", "=", "(", "ptl_size_t", ")", "USER_PROG_MEM_SIZE", ";", "md", ".", "start", "=", "(", "void", "*", ")", "USER_PROG_MEM_START", ";", "md", ".", "options", "=", "PTL_MD_EVENT_CT_ACK", "|", "PTL_MD_EVENT_CT_REPLY", "|", "PTL_MD_EVENT_SUCCESS_DISABLE", ";", "md", ".", "eq_handle", "=", "gupcr_atomic_md_eq", ";", "md", ".", "ct_handle", "=", "gupcr_atomic_md_ct", ";", "gupcr_portals_call", "(", "PtlMDBind", ",", "(", "gupcr_ptl_ni", ",", "&", "md", ",", "&", "gupcr_atomic_md", ")", ")", ";", "gupcr_atomic_md_count", "=", "0", ";", "}" ]

[ "Initialize", "atomics", "resources", "." ]

[ "/* Setup the Portals MD for local source/destination copying.\n We need to map the whole user's space (same as gmem). */", "/* Reset number of acknowledgments. */" ]

[]

[ "Apache-2.0" ]

[ "Release", "atomics", "resources", ".", "@ingroup", "INIT" ]

[ "void", "gupcr_atomic_fini", "(", "void", ")", "{", "gupcr_log", "(", "FC_ATOMIC", ",", "\"", "\"", ")", ";", "gupcr_portals_call", "(", "PtlMDRelease", ",", "(", "gupcr_atomic_md", ")", ")", ";", "gupcr_portals_call", "(", "PtlCTFree", ",", "(", "gupcr_atomic_md_ct", ")", ")", ";", "gupcr_portals_call", "(", "PtlEQFree", ",", "(", "gupcr_atomic_md_eq", ")", ")", ";", "}" ]

[ "Release", "atomics", "resources", "." ]

[ "/* Release atomic MD and its resources. */" ]

[]

[ "Apache-2.0" ]

[ "Allocate", "memory", "for", "this", "thread", "'", "s", "shared", "space", "contribution", ".", "Calculate", "needed", "memory", "size", "and", "let", "the", "node", "allocate", "shared", "memory", "and", "map", "other", "thread", "'", "s", "shared", "memory", "into", "the", "current", "thread", "memory", "space", "." ]

[ "static", "void", "gupcr_gmem_alloc_shared", "(", "void", ")", "{", "size_t", "heap_size", "=", "GUPCR_ROUND", "(", "gupcr_get_shared_heap_size", "(", ")", ",", "C64K", ")", ";", "size_t", "data_size", "=", "GUPCR_ROUND", "(", "GUPCR_SHARED_SECTION_END", "-", "GUPCR_SHARED_SECTION_START", ",", "C64K", ")", ";", "gupcr_gmem_heap_base_offset", "=", "data_size", ";", "gupcr_gmem_heap_size", "=", "heap_size", ";", "gupcr_gmem_size", "=", "heap_size", "+", "data_size", ";", "gupcr_gmem_base", "=", "gupcr_node_local_alloc", "(", "gupcr_gmem_size", ")", ";", "}" ]

[ "Allocate", "memory", "for", "this", "thread", "'", "s", "shared", "space", "contribution", "." ]

[ "/* Allocate this thread's shared space. */" ]

[]

[ "Apache-2.0" ]

[ "Complete", "all", "outstanding", "remote", "GET", "operations", ".", "This", "procedure", "waits", "for", "all", "outstanding", "GET", "operations", "to", "complete", ".", "If", "the", "wait", "on", "the", "Portals", "GET", "counting", "event", "returns", "a", "failure", "a", "full", "event", "queue", "is", "checked", "for", "failure", "specifics", "and", "the", "program", "aborts", "." ]

[ "void", "gupcr_gmem_sync_gets", "(", "void", ")", "{", "GUPCR_MEM_BARRIER", "(", ")", ";", "if", "(", "gupcr_gmem_gets", ".", "num_pending", ">", "0", ")", "{", "ptl_size_t", "num_initiated", "=", "gupcr_gmem_gets", ".", "num_completed", "+", "gupcr_gmem_gets", ".", "num_pending", ";", "ptl_ct_event_t", "ct", ";", "gupcr_debug", "(", "FC_MEM", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "gupcr_gmem_gets", ".", "num_pending", ")", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_gmem_gets", ".", "ct_handle", ",", "num_initiated", ",", "&", "ct", ")", ")", ";", "gupcr_gmem_gets", ".", "num_pending", "=", "0", ";", "gupcr_gmem_gets", ".", "num_completed", "=", "num_initiated", ";", "if", "(", "ct", ".", "failure", ">", "0", ")", "{", "gupcr_process_fail_events", "(", "gupcr_gmem_gets", ".", "eq_handle", ")", ";", "gupcr_abort", "(", ")", ";", "}", "}", "}" ]

[ "Complete", "all", "outstanding", "remote", "GET", "operations", "." ]

[ "/* Sync all outstanding local accesses. */", "/* Sync all outstanding remote get accesses. */" ]

[]

[ "Apache-2.0" ]

[ "Complete", "outstanding", "remote", "PUT", "operations", ".", "This", "procedure", "waits", "for", "all", "outstanding", "PUT", "operations", "to", "complete", ".", "If", "the", "wait", "on", "the", "Portals", "PUT", "counting", "event", "returns", "a", "failure", "a", "full", "event", "queue", "is", "checked", "for", "failure", "specifics", "and", "the", "program", "aborts", "." ]

[ "void", "gupcr_gmem_sync_puts", "(", "void", ")", "{", "GUPCR_MEM_BARRIER", "(", ")", ";", "if", "(", "gupcr_gmem_puts", ".", "num_pending", ">", "0", ")", "{", "ptl_size_t", "num_initiated", "=", "gupcr_gmem_puts", ".", "num_completed", "+", "gupcr_gmem_puts", ".", "num_pending", ";", "ptl_ct_event_t", "ct", ";", "gupcr_debug", "(", "FC_MEM", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "gupcr_gmem_puts", ".", "num_pending", ")", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_gmem_puts", ".", "ct_handle", ",", "num_initiated", ",", "&", "ct", ")", ")", ";", "gupcr_gmem_puts", ".", "num_pending", "=", "0", ";", "gupcr_gmem_puts", ".", "num_completed", "=", "num_initiated", ";", "gupcr_pending_strict_put", "=", "0", ";", "gupcr_gmem_put_bb_used", "=", "0", ";", "if", "(", "ct", ".", "failure", ">", "0", ")", "{", "gupcr_process_fail_events", "(", "gupcr_gmem_puts", ".", "eq_handle", ")", ";", "gupcr_abort", "(", ")", ";", "}", "}", "}" ]

[ "Complete", "outstanding", "remote", "PUT", "operations", "." ]

[ "/* Sync all outstanding local accesses. */", "/* Sync all outstanding remote put accesses. */" ]

[]

[ "Apache-2.0" ]

[ "Complete", "all", "outstanding", "remote", "operations", ".", "Check", "and", "wait", "for", "completion", "of", "all", "PUT", "/", "GET", "operations", "." ]

[ "void", "gupcr_gmem_sync", "(", "void", ")", "{", "gupcr_gmem_sync_gets", "(", ")", ";", "gupcr_gmem_sync_puts", "(", ")", ";", "}" ]

[ "Complete", "all", "outstanding", "remote", "operations", "." ]

[]

[]

[ "Apache-2.0" ]

[ "Read", "data", "from", "remote", "shared", "memory", ".", "A", "GET", "request", "is", "broken", "into", "multiple", "PtlGet", "()", "requests", "if", "the", "number", "of", "requested", "bytes", "is", "greater", "then", "the", "configuration", "limited", "maximum", "message", "size", ".", "@param", "[", "in", "]", "dest", "Local", "memory", "to", "receive", "remote", "data", "@param", "[", "in", "]", "thread", "Remote", "thread", "to", "request", "data", "from", "@param", "[", "in", "]", "offset", "Remote", "address", "@param", "[", "in", "]", "n", "Number", "of", "bytes", "to", "transfer" ]

[ "void", "gupcr_gmem_get", "(", "void", "*", "dest", ",", "int", "thread", ",", "size_t", "offset", ",", "size_t", "n", ")", "{", "ptl_process_t", "rpid", ";", "char", "*", "dest_addr", "=", "(", "char", "*", ")", "dest", "-", "(", "size_t", ")", "USER_PROG_MEM_START", ";", "size_t", "rem_offset", "=", "offset", ";", "size_t", "n_rem", "=", "n", ";", "gupcr_debug", "(", "FC_MEM", ",", "\"", "\"", ",", "thread", ",", "(", "long", "unsigned", ")", "offset", ",", "(", "long", "unsigned", ")", "dest", ")", ";", "rpid", ".", "rank", "=", "thread", ";", "while", "(", "n_rem", ">", "0", ")", "{", "size_t", "n_xfer", ";", "n_xfer", "=", "GUPCR_MIN", "(", "n_rem", ",", "(", "size_t", ")", "GUPCR_MAX_MSG_SIZE", ")", ";", "++", "gupcr_gmem_gets", ".", "num_pending", ";", "gupcr_portals_call", "(", "PtlGet", ",", "(", "gupcr_gmem_gets", ".", "md", ",", "(", "ptl_size_t", ")", "dest_addr", ",", "n_xfer", ",", "rpid", ",", "GUPCR_PTL_PTE_GMEM", ",", "PTL_NO_MATCH_BITS", ",", "rem_offset", ",", "PTL_NULL_USER_PTR", ")", ")", ";", "n_rem", "-=", "n_xfer", ";", "dest_addr", "+=", "n_xfer", ";", "rem_offset", "+=", "n_xfer", ";", "}", "}" ]

[ "Read", "data", "from", "remote", "shared", "memory", "." ]

[]

[ { "param": "dest", "type": "void" }, { "param": "thread", "type": "int" }, { "param": "offset", "type": "size_t" }, { "param": "n", "type": "size_t" } ]

[ "Apache-2.0" ]

[ "Write", "data", "to", "remote", "shared", "memory", ".", "For", "data", "requests", "smaller", "then", "maximum", "safe", "size", "the", "data", "is", "first", "copied", "into", "a", "bounce", "buffer", ".", "In", "this", "way", "the", "put", "operation", "can", "be", "non", "-", "blocking", "and", "there", "are", "no", "restrictions", "placed", "upon", "the", "caller", "'", "s", "use", "of", "the", "source", "data", "buffer", ".", "Otherwise", "a", "synchronous", "operation", "is", "performed", "and", "this", "function", "returns", "to", "the", "caller", "after", "the", "operation", "completes", ".", "@param", "[", "in", "]", "thread", "Destination", "thread", "@param", "[", "in", "]", "offset", "Destination", "offset", "@param", "[", "in", "]", "src", "Local", "source", "pointer", "to", "data", "@param", "[", "in", "]", "n", "Number", "of", "bytes", "to", "transfer" ]

[ "void", "gupcr_gmem_put", "(", "int", "thread", ",", "size_t", "offset", ",", "const", "void", "*", "src", ",", "size_t", "n", ")", "{", "int", "must_sync", "=", "(", "n", ">", "GUPCR_GMEM_MAX_SAFE_PUT_SIZE", ")", ";", "char", "*", "src_addr", "=", "(", "char", "*", ")", "src", ";", "size_t", "n_rem", "=", "n", ";", "ptl_process_t", "rpid", ";", "gupcr_debug", "(", "FC_MEM", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "src", ",", "thread", ",", "(", "long", "unsigned", ")", "offset", ")", ";", "rpid", ".", "rank", "=", "thread", ";", "while", "(", "n_rem", ">", "0", ")", "{", "size_t", "n_xfer", ";", "ptl_handle_md_t", "md_handle", ";", "ptl_size_t", "local_offset", ";", "n_xfer", "=", "GUPCR_MIN", "(", "n_rem", ",", "(", "size_t", ")", "GUPCR_MAX_MSG_SIZE", ")", ";", "if", "(", "must_sync", ")", "{", "local_offset", "=", "src_addr", "-", "(", "char", "*", ")", "USER_PROG_MEM_START", ";", "md_handle", "=", "gupcr_gmem_puts", ".", "md", ";", "}", "else", "if", "(", "n_rem", "<=", "GUPCR_MAX_VOLATILE_SIZE", ")", "{", "local_offset", "=", "src_addr", "-", "(", "char", "*", ")", "USER_PROG_MEM_START", ";", "md_handle", "=", "gupcr_gmem_puts", ".", "md_volatile", ";", "}", "else", "{", "char", "*", "bounce_buf", ";", "if", "(", "(", "gupcr_gmem_put_bb_used", "+", "n_xfer", ")", ">", "GUPCR_BOUNCE_BUFFER_SIZE", ")", "gupcr_gmem_sync_puts", "(", ")", ";", "bounce_buf", "=", "&", "gupcr_gmem_put_bb", "[", "gupcr_gmem_put_bb_used", "]", ";", "memcpy", "(", "bounce_buf", ",", "src_addr", ",", "n_xfer", ")", ";", "local_offset", "=", "bounce_buf", "-", "gupcr_gmem_put_bb", ";", "gupcr_gmem_put_bb_used", "+=", "n_xfer", ";", "md_handle", "=", "gupcr_gmem_put_bb_md", ";", "}", "++", "gupcr_gmem_puts", ".", "num_pending", ";", "gupcr_portals_call", "(", "PtlPut", ",", "(", "md_handle", ",", "local_offset", ",", "n_xfer", ",", "PTL_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_GMEM", ",", "PTL_NO_MATCH_BITS", ",", "offset", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ")", ")", ";", "n_rem", "-=", "n_xfer", ";", "src_addr", "+=", "n_xfer", ";", "if", "(", "gupcr_gmem_puts", ".", "num_pending", "==", "gupcr_gmem_high_mark_puts", ")", "{", "ptl_ct_event_t", "ct", ";", "size_t", "complete_cnt", ";", "size_t", "wait_cnt", "=", "gupcr_gmem_puts", ".", "num_completed", "+", "gupcr_gmem_puts", ".", "num_pending", "-", "gupcr_gmem_low_mark_puts", ";", "gupcr_portals_call", "(", "PtlCTWait", ",", "(", "gupcr_gmem_puts", ".", "ct_handle", ",", "wait_cnt", ",", "&", "ct", ")", ")", ";", "if", "(", "ct", ".", "failure", ">", "0", ")", "{", "gupcr_process_fail_events", "(", "gupcr_gmem_puts", ".", "eq_handle", ")", ";", "gupcr_abort", "(", ")", ";", "}", "complete_cnt", "=", "ct", ".", "success", "-", "gupcr_gmem_puts", ".", "num_completed", ";", "gupcr_gmem_puts", ".", "num_pending", "-=", "complete_cnt", ";", "gupcr_gmem_puts", ".", "num_completed", "=", "ct", ".", "success", ";", "}", "}", "if", "(", "must_sync", ")", "gupcr_gmem_sync_puts", "(", ")", ";", "}" ]

[ "Write", "data", "to", "remote", "shared", "memory", "." ]

[ "/* Large puts must be synchronous, to ensure that it is\n safe to re-use the source buffer upon return. */", "/* If this transfer will overflow the bounce buffer,\n\t then first wait for all outstanding puts to complete. */" ]

[ { "param": "thread", "type": "int" }, { "param": "offset", "type": "size_t" }, { "param": "src", "type": "void" }, { "param": "n", "type": "size_t" } ]

[ "Apache-2.0" ]

[ "Copy", "remote", "shared", "memory", "from", "the", "source", "thread", "to", "the", "destination", "thread", ".", "Bulk", "copy", "from", "one", "thread", "to", "another", ".", "The", "put", "bounce", "buffer", "is", "used", "as", "an", "intermediate", "buffer", ".", "Caller", "assumes", "responsibility", "for", "checking", "the", "validity", "of", "the", "remote", "thread", "id", "'", "s", "and", "/", "or", "shared", "memory", "offsets", "." ]

[ "void", "gupcr_gmem_copy", "(", "int", "dthread", ",", "size_t", "doffset", ",", "int", "sthread", ",", "size_t", "soffset", ",", "size_t", "n", ")", "{", "size_t", "n_rem", "=", "n", ";", "ptl_size_t", "dest_addr", "=", "doffset", ";", "ptl_size_t", "src_addr", "=", "soffset", ";", "ptl_process_t", "dpid", ";", "gupcr_debug", "(", "FC_MEM", ",", "\"", "\"", ",", "sthread", ",", "(", "long", "unsigned", ")", "soffset", ",", "dthread", ",", "(", "long", "unsigned", ")", "doffset", ",", "(", "long", "unsigned", ")", "n", ")", ";", "dpid", ".", "rank", "=", "dthread", ";", "while", "(", "n_rem", ">", "0", ")", "{", "size_t", "n_xfer", ";", "char", "*", "bounce_buf", ";", "ptl_size_t", "local_offset", ";", "n_xfer", "=", "GUPCR_MIN", "(", "n_rem", ",", "GUPCR_BOUNCE_BUFFER_SIZE", ")", ";", "if", "(", "(", "gupcr_gmem_put_bb_used", "+", "n_xfer", ")", ">", "GUPCR_BOUNCE_BUFFER_SIZE", ")", "gupcr_gmem_sync_puts", "(", ")", ";", "bounce_buf", "=", "&", "gupcr_gmem_put_bb", "[", "gupcr_gmem_put_bb_used", "]", ";", "gupcr_gmem_put_bb_used", "+=", "n_xfer", ";", "gupcr_gmem_get", "(", "bounce_buf", ",", "sthread", ",", "src_addr", ",", "n_xfer", ")", ";", "gupcr_gmem_sync_gets", "(", ")", ";", "local_offset", "=", "bounce_buf", "-", "gupcr_gmem_put_bb", ";", "++", "gupcr_gmem_puts", ".", "num_pending", ";", "gupcr_portals_call", "(", "PtlPut", ",", "(", "gupcr_gmem_put_bb_md", ",", "local_offset", ",", "n_xfer", ",", "PTL_ACK_REQ", ",", "dpid", ",", "GUPCR_PTL_PTE_GMEM", ",", "PTL_NO_MATCH_BITS", ",", "dest_addr", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ")", ")", ";", "n_rem", "-=", "n_xfer", ";", "src_addr", "+=", "n_xfer", ";", "dest_addr", "+=", "n_xfer", ";", "}", "}" ]

[ "Copy", "remote", "shared", "memory", "from", "the", "source", "thread", "to", "the", "destination", "thread", "." ]

[ "/* Use the entire put \"bounce buffer\" if the transfer\n count is sufficiently large. */", "/* Read the source data into the bounce buffer. */" ]

[ { "param": "dthread", "type": "int" }, { "param": "doffset", "type": "size_t" }, { "param": "sthread", "type": "int" }, { "param": "soffset", "type": "size_t" }, { "param": "n", "type": "size_t" } ]

[ "Apache-2.0" ]

[ "Write", "the", "same", "byte", "value", "into", "the", "bytes", "of", "the", "destination", "thread", "'", "s", "memory", "at", "the", "specified", "offset", ".", "The", "put", "bounce", "buffer", "is", "used", "as", "an", "intermediate", "buffer", ".", "The", "last", "write", "of", "a", "chunk", "of", "data", "is", "non", "-", "blocking", ".", "Caller", "assumes", "responsibility", "for", "checking", "the", "validity", "of", "the", "remote", "thread", "id", "'", "s", "and", "/", "or", "shared", "memory", "offsets", ".", "@param", "[", "in", "]", "thread", "Destination", "thread", "@param", "[", "in", "]", "offset", "Destination", "offset", "@param", "[", "in", "]", "c", "Set", "value", "@param", "[", "in", "]", "n", "Number", "of", "bytes", "to", "transfer" ]

[ "void", "gupcr_gmem_set", "(", "int", "thread", ",", "size_t", "offset", ",", "int", "c", ",", "size_t", "n", ")", "{", "size_t", "n_rem", "=", "n", ";", "int", "already_filled", "=", "0", ";", "ptl_size_t", "dest_addr", "=", "offset", ";", "ptl_process_t", "rpid", ";", "gupcr_debug", "(", "FC_MEM", ",", "\"", "\"", ",", "c", ",", "thread", ",", "(", "long", "unsigned", ")", "offset", ",", "(", "long", "unsigned", ")", "n", ")", ";", "rpid", ".", "rank", "=", "thread", ";", "while", "(", "n_rem", ">", "0", ")", "{", "size_t", "n_xfer", ";", "char", "*", "bounce_buf", ";", "ptl_size_t", "local_offset", ";", "n_xfer", "=", "GUPCR_MIN", "(", "n_rem", ",", "(", "size_t", ")", "GUPCR_BOUNCE_BUFFER_SIZE", ")", ";", "if", "(", "(", "gupcr_gmem_put_bb_used", "+", "n_xfer", ")", ">", "GUPCR_BOUNCE_BUFFER_SIZE", ")", "gupcr_gmem_sync_puts", "(", ")", ";", "bounce_buf", "=", "&", "gupcr_gmem_put_bb", "[", "gupcr_gmem_put_bb_used", "]", ";", "gupcr_gmem_put_bb_used", "+=", "n_xfer", ";", "if", "(", "!", "already_filled", ")", "{", "memset", "(", "bounce_buf", ",", "c", ",", "n_xfer", ")", ";", "already_filled", "=", "(", "bounce_buf", "==", "gupcr_gmem_put_bb", "&&", "n_xfer", "==", "GUPCR_BOUNCE_BUFFER_SIZE", ")", ";", "}", "local_offset", "=", "bounce_buf", "-", "gupcr_gmem_put_bb", ";", "++", "gupcr_gmem_puts", ".", "num_pending", ";", "gupcr_portals_call", "(", "PtlPut", ",", "(", "gupcr_gmem_put_bb_md", ",", "local_offset", ",", "n_xfer", ",", "PTL_ACK_REQ", ",", "rpid", ",", "GUPCR_PTL_PTE_GMEM", ",", "PTL_NO_MATCH_BITS", ",", "dest_addr", ",", "PTL_NULL_USER_PTR", ",", "PTL_NULL_HDR_DATA", ")", ")", ";", "n_rem", "-=", "n_xfer", ";", "dest_addr", "+=", "n_xfer", ";", "}", "}" ]

[ "Write", "the", "same", "byte", "value", "into", "the", "bytes", "of", "the", "destination", "thread", "'", "s", "memory", "at", "the", "specified", "offset", "." ]

[ "/* Use the entire put \"bounce buffer\" if the transfer\n count is sufficiently large. */", "/* Fill the bounce buffer, if we haven't already. */" ]

[ { "param": "thread", "type": "int" }, { "param": "offset", "type": "size_t" }, { "param": "c", "type": "int" }, { "param": "n", "type": "size_t" } ]

[ "Apache-2.0" ]

[ "Initialize", "gmem", "resources", ".", "@ingroup", "INIT" ]

[ "void", "gupcr_gmem_init", "(", "void", ")", "{", "ptl_md_t", "md", ",", "md_volatile", ";", "ptl_le_t", "le", ";", "ptl_pt_index_t", "pte", ";", "gupcr_log", "(", "FC_MEM", ",", "\"", "\"", ")", ";", "gupcr_gmem_alloc_shared", "(", ")", ";", "gupcr_portals_call", "(", "PtlPTAlloc", ",", "(", "gupcr_ptl_ni", ",", "0", ",", "PTL_EQ_NONE", ",", "GUPCR_PTL_PTE_GMEM", ",", "&", "pte", ")", ")", ";", "if", "(", "pte", "!=", "GUPCR_PTL_PTE_GMEM", ")", "gupcr_fatal_error", "(", "\"", "\"", ")", ";", "gupcr_log", "(", "FC_MEM", ",", "\"", "\"", ",", "GUPCR_PTL_PTE_GMEM", ")", ";", "le", ".", "start", "=", "gupcr_gmem_base", ";", "le", ".", "length", "=", "gupcr_gmem_size", ";", "le", ".", "ct_handle", "=", "PTL_CT_NONE", ";", "le", ".", "uid", "=", "PTL_UID_ANY", ";", "le", ".", "options", "=", "PTL_LE_OP_PUT", "|", "PTL_LE_OP_GET", ";", "gupcr_portals_call", "(", "PtlLEAppend", ",", "(", "gupcr_ptl_ni", ",", "GUPCR_PTL_PTE_GMEM", ",", "&", "le", ",", "PTL_PRIORITY_LIST", ",", "NULL", ",", "&", "gupcr_gmem_le", ")", ")", ";", "gupcr_debug", "(", "FC_MEM", ",", "\"", "\"", ",", "(", "long", "unsigned", ")", "gupcr_gmem_base", ",", "(", "long", "unsigned", ")", "gupcr_gmem_size", ")", ";", "gupcr_gmem_gets", ".", "num_pending", "=", "0", ";", "gupcr_gmem_gets", ".", "num_completed", "=", "0", ";", "gupcr_gmem_gets", ".", "md_options", "=", "PTL_MD_EVENT_CT_REPLY", "|", "PTL_MD_EVENT_SUCCESS_DISABLE", ";", "gupcr_portals_call", "(", "PtlEQAlloc", ",", "(", "gupcr_ptl_ni", ",", "THREADS", ",", "&", "gupcr_gmem_gets", ".", "eq_handle", ")", ")", ";", "gupcr_portals_call", "(", "PtlCTAlloc", ",", "(", "gupcr_ptl_ni", ",", "&", "gupcr_gmem_gets", ".", "ct_handle", ")", ")", ";", "md", ".", "length", "=", "(", "ptl_size_t", ")", "USER_PROG_MEM_SIZE", ";", "md", ".", "start", "=", "(", "void", "*", ")", "USER_PROG_MEM_START", ";", "md", ".", "options", "=", "gupcr_gmem_gets", ".", "md_options", ";", "md", ".", "eq_handle", "=", "gupcr_gmem_gets", ".", "eq_handle", ";", "md", ".", "ct_handle", "=", "gupcr_gmem_gets", ".", "ct_handle", ";", "gupcr_portals_call", "(", "PtlMDBind", ",", "(", "gupcr_ptl_ni", ",", "&", "md", ",", "&", "gupcr_gmem_gets", ".", "md", ")", ")", ";", "gupcr_gmem_puts", ".", "num_pending", "=", "0", ";", "gupcr_gmem_puts", ".", "num_completed", "=", "0", ";", "gupcr_gmem_puts", ".", "md_options", "=", "PTL_MD_EVENT_CT_ACK", "|", "PTL_MD_EVENT_SUCCESS_DISABLE", ";", "gupcr_portals_call", "(", "PtlEQAlloc", ",", "(", "gupcr_ptl_ni", ",", "THREADS", ",", "&", "gupcr_gmem_puts", ".", "eq_handle", ")", ")", ";", "gupcr_portals_call", "(", "PtlCTAlloc", ",", "(", "gupcr_ptl_ni", ",", "&", "gupcr_gmem_puts", ".", "ct_handle", ")", ")", ";", "md", ".", "length", "=", "(", "ptl_size_t", ")", "USER_PROG_MEM_SIZE", ";", "md", ".", "start", "=", "(", "void", "*", ")", "USER_PROG_MEM_START", ";", "md", ".", "options", "=", "gupcr_gmem_puts", ".", "md_options", ";", "md", ".", "eq_handle", "=", "gupcr_gmem_puts", ".", "eq_handle", ";", "md", ".", "ct_handle", "=", "gupcr_gmem_puts", ".", "ct_handle", ";", "gupcr_portals_call", "(", "PtlMDBind", ",", "(", "gupcr_ptl_ni", ",", "&", "md", ",", "&", "gupcr_gmem_puts", ".", "md", ")", ")", ";", "md_volatile", "=", "md", ";", "md_volatile", ".", "options", "|=", "PTL_MD_VOLATILE", ";", "gupcr_portals_call", "(", "PtlMDBind", ",", "(", "gupcr_ptl_ni", ",", "&", "md_volatile", ",", "&", "gupcr_gmem_puts", ".", "md_volatile", ")", ")", ";", "md", ".", "length", "=", "GUPCR_BOUNCE_BUFFER_SIZE", ";", "md", ".", "start", "=", "gupcr_gmem_put_bb", ";", "md", ".", "options", "=", "gupcr_gmem_puts", ".", "md_options", ";", "md", ".", "eq_handle", "=", "gupcr_gmem_puts", ".", "eq_handle", ";", "md", ".", "ct_handle", "=", "gupcr_gmem_puts", ".", "ct_handle", ";", "gupcr_portals_call", "(", "PtlMDBind", ",", "(", "gupcr_ptl_ni", ",", "&", "md", ",", "&", "gupcr_gmem_put_bb_md", ")", ")", ";", "}" ]

[ "Initialize", "gmem", "resources", "." ]

[ "/* Allocate memory for this thread's contribution to shared memory. */", "/* Setup Gmem LE. */", "/* Initialize GMEM get lists */", "/* Allocate at least THREADS number of EQ entries. */", "/* Map user's address space for GET operations. */", "/* Initialize GMEM put lists. */", "/* Allocate at least THREADS number of EQ entries. */", "/* Map user's address space for PUT operations. */", "/* And map the same but with a volatile option. */", "/* Initialize GMEM put bounce buffer. */" ]

[]

[ "Apache-2.0" ]

[ "Release", "gmem", "resources", ".", "@ingroup", "INIT" ]

[ "void", "gupcr_gmem_fini", "(", "void", ")", "{", "gupcr_log", "(", "FC_MEM", ",", "\"", "\"", ")", ";", "gupcr_portals_call", "(", "PtlMDRelease", ",", "(", "gupcr_gmem_gets", ".", "md", ")", ")", ";", "gupcr_portals_call", "(", "PtlCTFree", ",", "(", "gupcr_gmem_gets", ".", "ct_handle", ")", ")", ";", "gupcr_portals_call", "(", "PtlEQFree", ",", "(", "gupcr_gmem_gets", ".", "eq_handle", ")", ")", ";", "gupcr_portals_call", "(", "PtlMDRelease", ",", "(", "gupcr_gmem_puts", ".", "md", ")", ")", ";", "gupcr_portals_call", "(", "PtlMDRelease", ",", "(", "gupcr_gmem_put_bb_md", ")", ")", ";", "gupcr_portals_call", "(", "PtlCTFree", ",", "(", "gupcr_gmem_puts", ".", "ct_handle", ")", ")", ";", "gupcr_portals_call", "(", "PtlEQFree", ",", "(", "gupcr_gmem_puts", ".", "eq_handle", ")", ")", ";", "gupcr_portals_call", "(", "PtlLEUnlink", ",", "(", "gupcr_gmem_le", ")", ")", ";", "gupcr_portals_call", "(", "PtlPTFree", ",", "(", "gupcr_ptl_ni", ",", "GUPCR_PTL_PTE_GMEM", ")", ")", ";", "}" ]

[ "Release", "gmem", "resources", "." ]

[ "/* Release GET MD. */", "/* Release PUT MDs. */", "/* Release LEs and PTEs. */" ]

[]

[ "Apache-2.0" ]

[ "Remove", "the", "file", "used", "for", "mmap", ".", "On", "Unix", "systems", "this", "removes", "the", "file", "name", "but", "since", "the", "file", "is", "open", "the", "underlying", "file", "storage", "will", "remain", "until", "the", "program", "terminates", "." ]

[ "void", "gupcr_mem_local_unlink", "(", "void", ")", "{", "unlink", "(", "gupcr_thread_local_name", ")", ";", "}" ]

[ "Remove", "the", "file", "used", "for", "mmap", "." ]

[]

[]

[ "Apache-2.0" ]

[ "GLIBC", "backtrace", ".", "Show", "backtrace", "by", "using", "the", "GLIBC", "backtrace", "functionality", ".", "Backtrace", "is", "improved", "with", "the", "source", "file", "/", "line", "numbers", "if", "addr2line", "is", "available", ".", "By", "default", "backtrace", "lines", "are", "sent", "to", "the", "'", "stderr", "'", "file", "descriptor", ".", "However", "an", "environment", "variable", "UPC_BACKTRACEFILE", "can", "be", "used", "to", "redirect", "the", "backtrace", "to", "an", "actual", "file", "and", "it", "is", "used", "as", "a", "simple", "prefix", "for", "the", "backtrace", "file", ".", "For", "example", "if", "it", "is", "set", "to", "\"", "/", "tmp", "/", "trace", "-", "upc", "\"", "the", "actual", "trace", "file", "is", "going", "to", "be", "\"", "/", "tmp", "/", "trace", "-", "upc", "-", "PID", ".", "MYTHREAD", "\"", ".", "If", "empty", "environment", "variable", "is", "provided", "a", "simple", "\"", "trace", "\"", "prefix", "is", "used", "." ]

[ "void", "gupcr_backtrace", "(", "void", ")", "{", "void", "*", "strace", "[", "GUPCR_BT_DEPTH_CNT", "]", ";", "size_t", "size", ",", "i", ";", "char", "*", "*", "strace_str", ";", "char", "*", "file_env", ";", "int", "under_upc_main", "=", "1", ";", "FILE", "*", "traceout", "=", "stderr", ";", "file_env", "=", "getenv", "(", "GUPCR_BACKTRACE_FILE_ENV", ")", ";", "if", "(", "file_env", ")", "{", "#define", "MAX_INT_STRING", " \".2147483647\"", "\n", "char", "*", "tracefile", ";", "int", "len", ",", "lenw", ";", "if", "(", "!", "strlen", "(", "file_env", ")", ")", "file_env", "=", "(", "char", "*", ")", "UPC_BACKTRACE_PREFIX", ";", "len", "=", "strlen", "(", "file_env", ")", "+", "strlen", "(", "MAX_INT_STRING", ")", "+", "1", ";", "tracefile", "=", "malloc", "(", "len", ")", ";", "if", "(", "!", "tracefile", ")", "gupcr_fatal_error", "(", "\"", "\"", ",", "len", ",", "file_env", ")", ";", "lenw", "=", "snprintf", "(", "tracefile", ",", "len", ",", "\"", "\"", ",", "file_env", ",", "MYTHREAD", ")", ";", "if", "(", "(", "lenw", ">=", "len", ")", "||", "(", "lenw", "<", "0", ")", ")", "gupcr_fatal_error", "(", "\"", "\"", ",", "file_env", ")", ";", "traceout", "=", "fopen", "(", "tracefile", ",", "\"", "\"", ")", ";", "if", "(", "!", "traceout", ")", "gupcr_fatal_error", "(", "\"", "\"", ",", "tracefile", ")", ";", "free", "(", "tracefile", ")", ";", "}", "else", "fprintf", "(", "traceout", ",", "\"", "\\n", "\"", ",", "MYTHREAD", ")", ";", "size", "=", "backtrace", "(", "strace", ",", "GUPCR_BT_DEPTH_CNT", ")", ";", "for", "(", "i", "=", "GUPCR_BT_SKIP_FRAME_CNT", ";", "i", "<", "size", ";", "i", "++", ")", "{", "if", "(", "under_upc_main", ")", "{", "# if", "HAVE_UPC_BACKTRACE_ADDR2LINE", "\n", "FILE", "*", "a2l", ";", "#define", "CMD_TMPL", " \"%s -f -e %s %p\"", "\n", "int", "cmd_size", "=", "strlen", "(", "GUPCR_BACKTRACE_ADDR2LINE", ")", "+", "strlen", "(", "gupcr_abs_execname", ")", "+", "strlen", "(", "CMD_TMPL", ")", "+", "strlen", "(", "\"", "\"", ")", ";", "int", "sz", ";", "char", "*", "cmd", "=", "malloc", "(", "cmd_size", ")", ";", "sz", "=", "snprintf", "(", "cmd", ",", "cmd_size", ",", "CMD_TMPL", ",", "GUPCR_BACKTRACE_ADDR2LINE", ",", "gupcr_abs_execname", ",", "strace", "[", "i", "]", ")", ";", "if", "(", "(", "sz", ">=", "cmd_size", ")", "||", "(", "sz", "<", "0", ")", ")", "{", "fprintf", "(", "traceout", ",", "\"", "\"", "\"", "\\n", "\"", ")", ";", "return", ";", "}", "a2l", "=", "popen", "(", "cmd", ",", "\"", "\"", ")", ";", "free", "(", "cmd", ")", ";", "if", "(", "a2l", ")", "{", "int", "max_rep", "=", "2", "*", "FILENAME_MAX", ";", "struct", "back_trace", "{", "char", "*", "addr", ";", "char", "data", "[", "1", "]", ";", "}", ";", "struct", "back_trace", "*", "rep", "=", "malloc", "(", "max_rep", ")", ";", "int", "index", "=", "0", ";", "if", "(", "!", "rep", ")", "{", "fprintf", "(", "traceout", ",", "\"", "\"", "\"", "\\n", "\"", ")", ";", "return", ";", "}", "rep", "->", "data", "[", "0", "]", "=", "'", "\\0", "'", ";", "while", "(", "fgets", "(", "&", "rep", "->", "data", "[", "index", "]", ",", "max_rep", "-", "index", ",", "a2l", ")", ")", "{", "index", "=", "strlen", "(", "&", "rep", "->", "data", "[", "0", "]", ")", ";", "if", "(", "rep", "->", "data", "[", "index", "-", "1", "]", "==", "'", "\\n", "'", ")", "rep", "->", "data", "[", "index", "-", "1", "]", "=", "'", "'", ";", "}", "pclose", "(", "a2l", ")", ";", "rep", "->", "addr", "=", "&", "rep", "->", "data", "[", "0", "]", ";", "strace_str", "=", "&", "rep", "->", "addr", ";", "}", "else", "{", "strace_str", "=", "backtrace_symbols", "(", "&", "strace", "[", "i", "]", ",", "1", ")", ";", "}", "# else", "strace_str", "=", "backtrace_symbols", "(", "&", "strace", "[", "i", "]", ",", "1", ")", ";", "# endif", "fprintf", "(", "traceout", ",", "\"", "\\n", "\"", ",", "MYTHREAD", ",", "(", "long", "long", "int", ")", "(", "i", "-", "GUPCR_BT_SKIP_FRAME_CNT", ")", ",", "*", "strace_str", ")", ";", "if", "(", "strstr", "(", "*", "strace_str", ",", "\"", "\"", ")", ")", "{", "fprintf", "(", "traceout", ",", "\"", "\\n", "\"", ",", "MYTHREAD", ",", "gupcr_barrier_id", ")", ";", "}", "if", "(", "strstr", "(", "*", "strace_str", ",", "\"", "\"", ")", ")", "under_upc_main", "=", "0", ";", "free", "(", "strace_str", ")", ";", "}", "}", "fflush", "(", "traceout", ")", ";", "if", "(", "file_env", ")", "fclose", "(", "traceout", ")", ";", "}" ]

[ "GLIBC", "backtrace", "." ]

[ "/* Use default trace file name if one not specified by the user. */", "/* Use \"backtrace\" functionality of glibc to receive\n backtrace addresses. */", "/* Add symbolic information to each address\n and print the stack trace. */", "/* Call addr2line to generate source files, line numbers,\n\t and functions. In case of any error (malloc, snprintf)\n\t do not abort the program. */", "/* Allow space for addr2line, filename, command line options,\n\t and address argument for addr2line. */", "/* Create an actual addr2line command. */", "/* Execute addr2line. */", "/* addr2line responds with two lines: procedure name and\n\t\t the file name with line number. */", "/* Build a data structure that is identical to the\n\t\t structure returned by the glibc backtrace_symbol(). */", "/* Read addr2line response. */", "/* Remove all the new lines, as addr2line returns\n\t\t info in multiple lines. */", "/* Somehow we failed to invoke addr2line, fall back\n\t to glibc. */", "/* Extra info for the barrier. */", "/* Symbol trace buffer must be released. */" ]

[]

[ "Apache-2.0" ]

[ "Backtrace", "on", "fatal", "errors", ".", "Print", "backtrace", "(", "stack", "frames", ")", "on", "fatal", "errors", ":", "run", "-", "time", "fatal", "error", "or", "segmentation", "fault", ".", "Only", "print", "backtrace", "if", "environment", "variable", "UPC_BACKTRACE", "is", "set", "to", "1", ".", "The", "following", "order", "of", "backtrace", "capabilities", "is", "searched", "and", "executed", ".", "(", "1", ")", "Use", "GDB", "for", "backtrace", "(", "if", "enabled", ")", "(", "2", ")", "Use", "GLIBC", "backtrace", "with", "source", "file", "/", "line", "display", "(", "if", "addr2line", "is", "available", ")", "(", "3", ")", "Use", "GLIBC", "backtrace", "with", "raw", "addresses", "(", "display", "is", "improved", "if", "-", "rdynamic", "option", "is", "supported", "by", "the", "linker", ")" ]

[ "void", "gupcr_fatal_error_backtrace", "(", "void", ")", "{", "if", "(", "bt_enabled", ")", "{", "#ifdef", "HAVE_UPC_BACKTRACE_GDB", "{", "char", "*", "env", ";", "const", "char", "*", "gdb", ";", "char", "pid_buf", "[", "GUPCR_BACKTRACE_PID_BUFLEN", "]", ";", "int", "child_pid", ";", "env", "=", "getenv", "(", "GUPCR_BACKTRACE_GDB_ENV", ")", ";", "if", "(", "!", "env", "||", "(", "strlen", "(", "env", ")", "==", "0", ")", ")", "gdb", "=", "GUPCR_BACKTRACE_GDB", ";", "else", "gdb", "=", "(", "const", "char", "*", ")", "env", ";", "if", "(", "strcmp", "(", "gdb", ",", "\"", "\"", ")", ")", "{", "const", "char", "*", "err_msg", "=", "0", ";", "char", "tmpf", "[", "PATH_MAX", "]", ";", "int", "fbt", ";", "const", "char", "*", "btcmd", "=", "\"", "\\n", "\"", ";", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "MYTHREAD", ")", ";", "sprintf", "(", "pid_buf", ",", "\"", "\"", ",", "getpid", "(", ")", ")", ";", "if", "(", "(", "fbt", "=", "gupcr_create_temp_file", "(", "\"", "\"", ",", "tmpf", ",", "&", "err_msg", ")", ")", "==", "-1", ")", "{", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "err_msg", ")", ";", "return", ";", "}", "if", "(", "write", "(", "fbt", ",", "btcmd", ",", "sizeof", "(", "btcmd", ")", ")", "==", "-1", ")", "{", "perror", "(", "\"", "\"", ")", ";", "return", ";", "}", "if", "(", "close", "(", "fbt", ")", ")", "{", "perror", "(", "\"", "\"", ")", ";", "return", ";", "}", "child_pid", "=", "fork", "(", ")", ";", "if", "(", "!", "child_pid", ")", "{", "dup2", "(", "2", ",", "1", ")", ";", "execlp", "(", "gdb", ",", "gdb", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "tmpf", ",", "gupcr_abs_execname", ",", "pid_buf", ",", "NULL", ")", ";", "fprintf", "(", "stderr", ",", "\"", "\\n", "\"", ",", "gdb", ")", ";", "abort", "(", ")", ";", "}", "else", "waitpid", "(", "child_pid", ",", "NULL", ",", "0", ")", ";", "unlink", "(", "tmpf", ")", ";", "return", ";", "}", "}", "#endif", "gupcr_backtrace", "(", ")", ";", "}", "}" ]

[ "Backtrace", "on", "fatal", "errors", "." ]

[ "/* Which gdb to use? */", "/* Get pid and name of the running program. */", "/* Create temp file for GDB commands. */", "/* If gdb failed to start */", "/* GUPCR_BACKTRACE_GDB */", "/* Simple backtrace only. */" ]

[]

[ "Apache-2.0" ]

[ "Restore", "default", "handlers", ".", "Has", "to", "be", "called", "once", "the", "run", "-", "time", "discovered", "a", "fatal", "error", "." ]

[ "void", "gupcr_backtrace_restore_handlers", "(", "void", ")", "{", "signal", "(", "SIGABRT", ",", "SIG_DFL", ")", ";", "signal", "(", "SIGILL", ",", "SIG_DFL", ")", ";", "signal", "(", "SIGSEGV", ",", "SIG_DFL", ")", ";", "signal", "(", "SIGBUS", ",", "SIG_DFL", ")", ";", "signal", "(", "SIGFPE", ",", "SIG_DFL", ")", ";", "}" ]

[ "Restore", "default", "handlers", "." ]

[ "/* Don't handle any signals with backtrace code. Install\n default handlers. */" ]

[]