static int
int64_le(lua_State *L) {
int64_t a = _int64(L,1);
int64_t b = _int64(L,2);
lua_pushboolean(L,a <= b);
return 1;
}
static int
int64_sub(lua_State *L) {
int64_t a = _int64(L,1);
int64_t b = _int64(L,2);
_pushint64(L, a-b);
return 1;
}
static int
int64_add(lua_State *L) {
int64_t a = _int64(L,1);
int64_t b = _int64(L,2);
_pushint64(L, a+b);
return 1;
}
static int
int64_eq(lua_State *L) {
// __eq metamethod can't be invoke by lightuserdata
int64_t a = _int64(L,1);
int64_t b = _int64(L,2);
lua_pushboolean(L,a == b);
return 1;
}
static int
int64_mul(lua_State *L) {
int64_t a = _int64(L,1);
int64_t b = _int64(L,2);
_pushint64(L, a * b);
return 1;
}
static int
int64_mod(lua_State *L) {
int64_t a = _int64(L,1);
int64_t b = _int64(L,2);
if (b == 0) {
return luaL_error(L, "mod by zero");
}
_pushint64(L, a % b);
return 1;
}
static int
int64_div(lua_State *L) {
int64_t a = _int64(L,1);
int64_t b = _int64(L,2);
if (b == 0) {
return luaL_error(L, "div by zero");
}
_pushint64(L, a / b);
return 1;
}
static int
int64_new(lua_State *L) {
int top = lua_gettop(L);
int64_t n;
switch(top) {
case 0 :
lua_pushlightuserdata(L,NULL);
break;
case 1 :
n = _int64(L,1);
_pushint64(L,n);
break;
default: {
int base = luaL_checkinteger(L,2);
if (base < 2) {
luaL_error(L, "base must be >= 2");
}
const char * str = luaL_checkstring(L, 1);
n = strtoll(str, NULL, base);
_pushint64(L,n);
break;
}
}
return 1;
}
static int
int64_pow(lua_State *L) {
int64_t a = _int64(L,1);
int64_t b = _int64(L,2);
int64_t p;
if (b > 0) {
p = _pow64(a,b);
} else if (b == 0) {
p = 1;
} else {
return luaL_error(L, "pow by nagtive number %d",(int)b);
}
_pushint64(L, p);
return 1;
}
FilterOnesIterator& FilterOnesIterator::operator++()
{
BHASSERT_WITH_NO_PERFORMANCE_IMPACT(valid); // cannot iterate invalid iterator
BHASSERT_WITH_NO_PERFORMANCE_IMPACT(packs_to_go==-1 || packs_to_go > packs_done);
if(IsEndOfBlock()) {
if(!IteratorBpp()) {
valid = false;
return *this;
}
} else
iterator_n++; // now we are on the first suspected position - go forward if it is not 1
bool found = false;
while(!found) {
if(cur_block_full) {
found = true;
} else if(cur_block_empty) { //Updating iterator can cause this
if(!IteratorBpp()) {
valid = false;
return *this;
}
} else {
found = FindOneInsidePack();
if(!found) {
if(!IteratorBpp()) {
valid = false;
return *this;
}
}
}
}
cur_position = ((_int64(iterator_b)) << 16) + iterator_n;
return *this;
}
void FilterOnesIterator::RewindToRow(const _int64 row) // note: if row not exists , set IsValid() to false
{
int pack = int(row >> 16);
if(pack >= f->no_blocks ||
(pack == f->no_blocks-1 && (row & 0xffff) >= f->no_of_bits_in_last_block))
valid = false;
else
valid = true;
BHASSERT_WITH_NO_PERFORMANCE_IMPACT(pack >= 0 && pack < f->no_blocks);
iterator_b = prev_iterator_b = pack ;
iterator_n = int(row & 0xffff);
uchar stat = f->block_status[iterator_b];
cur_block_full = (stat == f->FB_FULL);
cur_block_empty = (stat == f->FB_EMPTY);
buffer.Reset(); // random order - forget history
if(cur_block_empty) {
valid = false;
return;
}
packs_done = 0;
if(stat == f->FB_MIXED)
if(!f->Get(row))
valid = false;
else
ones_left_in_block = f->blocks[iterator_b]->no_set_bits;
cur_position = ((_int64(iterator_b)) << 16) + iterator_n;
}
bool FilterOnesIterator::NextInsidePack() // return false if we just restarted the pack after going to its end
{
bool inside_pack = true;
if(IsEndOfBlock()) {
inside_pack = false;
iterator_n = 0;
prev_block = -1;
} else
iterator_n++; // now we are on the first suspected position - go forward if it is not 1
bool found = false;
while(!found) {
if(cur_block_full) {
found = true;
} else if(cur_block_empty) { //Updating iterator can cause this
return false;
} else {
found = FindOneInsidePack();
if(!found) {
inside_pack = false;
iterator_n = 0;
prev_block = -1;
}
}
}
cur_position = ((_int64(iterator_b)) << 16) + iterator_n;
return inside_pack;
}
bool FilterOnesIterator::RewindToPack(int pack)
{
// if SetNoPacksToGo() has been used, then RewindToPack can be done only to the previous pack
assert(packs_to_go == -1 || pack == prev_iterator_b || pack == iterator_b);
if(pack >= f->no_blocks)
valid = false;
else
valid = true;
if(iterator_b != pack)
packs_done--;
iterator_b = prev_iterator_b = pack;
prev_block = pack;
b = 0;
bitsLeft = 0;
lastn = -2;
bln = 0;
iterator_n = 0;
uchar stat = f->block_status[iterator_b];
cur_block_full = (stat == f->FB_FULL);
cur_block_empty = (stat == f->FB_EMPTY);
// assert(buffer.Empty()); // random order - forget history, WARNING: may lead to omitting packs!
buffer.Reset();
if(cur_block_empty) {
NextPack();
return false;
}
if(!cur_block_full) {
iterator_n = -1;
FilterOnesIterator::operator++();
ones_left_in_block = f->blocks[iterator_b]->no_set_bits;
}
cur_position = ((_int64(iterator_b)) << 16) + iterator_n;
return true;
}
_int64 FilterOnesIterator::GetPackSizeLeft() // how many 1-s in the current block left (including the current one)
{
if(!valid)
return 0;
if(cur_block_full)
return _int64(f->block_last_one[iterator_b]) + 1 - iterator_n; BHASSERT_WITH_NO_PERFORMANCE_IMPACT(f->block_status[iterator_b] != f->FB_EMPTY);
return ones_left_in_block;
}
void JoinerHashTable::Initialize(_int64 max_table_size, bool easy_roughable)
{
// Input buffer format: <key_1><key_2>...<key_n>
// Table format: <key_1><key_2>...<key_n><tuple_1>...<tuple_m><multiplier>
if(max_table_size < 2) // otherwise strange things may occur
max_table_size = 2;
if(initialized)
return;
AddTupleColumn(8); // add multiplier column
no_key_attr = int(encoder.size());
no_attr = int(size.size());
if(no_key_attr==0)
return;
if(no_attr - no_key_attr == 1) // i.e. no tuple columns, just a multiplier
for_count_only = true;
column_offset = new int [no_attr];
// Prepare buffers and mappings
key_buf_width = 0;
for(int i = 0; i < no_key_attr; i++) {
encoder[i].SetPrimaryOffset(key_buf_width);
key_buf_width += size[i];
}
key_buf_width = 4 * ( (key_buf_width + 3) / 4); // e.g. 1->4, 12->12, 19->20
total_width = key_buf_width;
for(int i = no_key_attr; i < no_attr; i++) {
column_offset[i] = total_width;
total_width += size[i];
}
mult_offset = column_offset[no_attr - 1];
/////////// create buffers ////////////////////
if((max_table_size + 1) * total_width * 1.25 < 64 * MBYTE)
no_rows = _int64((max_table_size + 1) * 1.25); // make sure that rows_limit>=max_no_groups
else {
// for easy roughable case the buffer may be smaller
no_rows = TrackableObject::MaxBufferSize(easy_roughable ? -3 : 0) / total_width; // memory limitation
if((max_table_size + 1) * 1.25 < no_rows)
no_rows = _int64((max_table_size + 1) * 1.25);
}
// calculate vertical size (not dividable by a set of some prime numbers)
if(no_rows < min_prime_not_in_table ) // too less rows => high collision probability
no_rows = min_prime_not_in_table;
else
no_rows = (no_rows / min_prime_not_in_table + 1) * min_prime_not_in_table;
// make sure that the size is not dividable by any of prime_steps
bool increased = false;
do {
increased = false;
for( int i = 0; i < prime_steps_no; i++ )
if( no_rows % prime_steps[i] == 0 ) {
increased = true;
no_rows += min_prime_not_in_table;
break;
}
} while(increased);
rows_limit = _int64(no_rows * 0.9); // rows_limit is used to determine whether the table is full
t = (unsigned char*)alloc(((total_width / 4) * no_rows) * 4, BLOCK_TEMPORARY); // no need to cache on disk
input_buffer = (unsigned char*)new unsigned int [key_buf_width / 4];
// initialize everything
ClearAll();
ConnectionInfo *m_conn = &ConnectionInfoOnTLS.Get();
rccontrol.lock(m_conn->GetThreadID()) << "Hash join buffer initialized for up to " << no_rows << " rows, "
<< key_buf_width << "+" << total_width - key_buf_width << " bytes." << unlock;
initialized = true;
}
////////////////////////////////////////////////////////////////////////////
// CHapticViewerView drawing
//
void CHapticViewerView::OnDraw(CDC* pDC)
{
CHapticViewerDoc* pDoc = GetDocument();
// Ceck pauseDraw to see if drawing should be paused to allow the user to
// respond to an error message box.
if (pDoc->m_pauseDraw) return;
Mesh* pObj = pDoc->getObj();
wglMakeCurrent(m_hDC,m_hRC);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (pObj)
{
static double s_hlElapsed = 0.0;
static double s_glElapsed = 0.0;
static double s_totalElapsed = 0.0;
static int s_hlTriCount = 0;
static int s_glTriCount = 0;
int hlTriCount = 0;
int glTriCount = 0;
double hlElapsed = 0.0;
double glElapsed = 0.0;
double totalElapsed = 0.0;
// Manage how often to update performance number to avoid smearing.
const double showPerfNumSec = 0.25;
LARGE_INTEGER startHapticli, startGraphicli, startTotalli, endli;
QueryPerformanceCounter(&startTotalli);
QueryPerformanceCounter(&startHapticli);
// Single pass render for both haptics and graphics.
m_bSinglePassRender = m_bShapeDepthBuffer && !m_bHapticCameraView;
//
// draw haptic scene
//
hlTriCount = drawSceneHL(pObj);
QueryPerformanceCounter(&endli);
hlElapsed = double(_int64(endli.QuadPart -
startHapticli.QuadPart)) / g_liFreq.QuadPart;
//
// draw graphic scene
//
QueryPerformanceCounter(&startGraphicli);
if (!m_bSinglePassRender)
{
// Use render produced by drawSceneHL (single pass render).
glPushAttrib(GL_POLYGON_BIT);
{
if (m_bWireframe)
{
glPolygonMode(GL_FRONT, GL_LINE);
}
const bool isHapticView = false;
glTriCount = drawSceneGL(pObj, isHapticView);
}
glPopAttrib();
}
drawCursorGL();
// Draw the frustum (if desired).
if (m_bHapticCameraVisual)
{
glPushMatrix();
glMultMatrixd(pObj->transform);
drawFrustum(m_hapticCameraFrustum);
glPopMatrix();
}
glFinish();
QueryPerformanceCounter(&endli);
glElapsed = double(_int64(endli.QuadPart -
startGraphicli.QuadPart)) / g_liFreq.QuadPart;
totalElapsed = double(_int64(endli.QuadPart -
startTotalli.QuadPart)) / g_liFreq.QuadPart;
// QueryPerformanceCounter(&endli);
double perfElapsed = double(_int64(endli.QuadPart -
g_drawPerfli.QuadPart)) / g_liFreq.QuadPart;
if ((perfElapsed > showPerfNumSec) &&
(hlTriCount > 0 || glTriCount > 0))
{
QueryPerformanceCounter(&g_drawPerfli);
s_hlElapsed = hlElapsed;
s_glElapsed = glElapsed;
s_totalElapsed = totalElapsed;
s_hlTriCount = hlTriCount;
s_glTriCount = glTriCount;
}
if (m_bPerformance)
{
drawPerformance(s_hlElapsed, s_glElapsed, s_totalElapsed,
s_hlTriCount, s_glTriCount);
}
Invalidate(FALSE);
}
SwapBuffers(m_hDC);
}
static int
int64_len(lua_State *L) {
int64_t a = _int64(L,1);
lua_pushnumber(L,(lua_Number)a);
return 1;
}
static int
int64_unm(lua_State *L) {
int64_t a = _int64(L,1);
_pushint64(L, -a);
return 1;
}
