Beispiel #1
0
    sIntBasePtr ShGcInt::bitwiseOr(sIntBasePtr& a, sIntBasePtr & b)
    {
        if (a->bitCount() != b->bitCount())
            throw RTE_LOC;

        auto aa = getMemory(a);
        auto bb = getMemory(b);
        auto ret(new ShGcInt(mRt, a->bitCount()));

        ShGc::CircuitItem workItem;
        workItem.mInputBundleCount = 2;
        workItem.mLabels.resize(3);
        workItem.mLabels[0] = aa;
        workItem.mLabels[1] = bb;
        workItem.mLabels[2] = ret->mLabels;

        workItem.mCircuit = mRt.mLibrary.int_int_bitwiseOr(
            workItem.mLabels[0]->size(),
            workItem.mLabels[1]->size(),
            workItem.mLabels[2]->size());

        mRt.enqueue(std::move(workItem));

        return sIntBasePtr(ret);
    }
ResultCode ObjectMemoryDeferFree::run() throw()
{
    const double minDuration = 0.000001;
    const double maxDuration = 0.1;
    double duration = minDuration;
    
    while (! getShouldExit())
    {
        plonk_assert (getMemory().getUserData() == this);

        Element d = queue->pop();
        
        if (d.ptr != 0)
        {
            duration = minDuration; // reset back to high speed
            staticDoFree (this, d.ptr);
        }
        else 
        {
            // gradually increase the amount of sleep if the queue is empty
            duration = plonk::min (duration * 2.0, maxDuration);
        }
        
        Threading::sleep (duration);
    }
    
    getMemory().resetFunctions();
    queue->clearAll();
    
    return 0;
}
Beispiel #3
0
	TEST_F(ListTest, CanRemoveItemFromMiddleOfList)
	{
		auto list = new Utils::List<FooMock>(getMemory(), listCapacity);

		list->emplace();
		list->emplace();
		FooMock& deletedItem = list->emplace();
		list->emplace();
		list->emplace();

		EXPECT_EQ(5, list->size());

		list->eraseAt(2);

		for(auto i = 0; i < list->size(); i++)
		{
			uint32_t number = (*list)[i].Quack();
			EXPECT_EQ(FooMock::fooConst, number);
		}

		EXPECT_EQ(4, list->size());
		EXPECT_EQ(sizeof(FooMock) * list->capacity(), getMemory().getAllocationSize(list->begin()));

		::testing::Mock::VerifyAndClearExpectations(&deletedItem);

		delete list;
	}
Beispiel #4
0
    sIntBasePtr ShGcInt::ifelse(sIntBasePtr& a, sIntBasePtr & ifTrue, sIntBasePtr & ifFalse)
    {

        auto aa = getMemory(a);
        auto tt = getMemory(ifTrue);
        auto ff = getMemory(ifFalse);
        auto ret(new ShGcInt(mRt, tt->size()));
        sIntBasePtr rret(ret);

        ShGc::CircuitItem workItem;
        workItem.mInputBundleCount = 3;
        workItem.mLabels.resize(4);
        workItem.mLabels[0] = tt;
        workItem.mLabels[1] = ff;
        workItem.mLabels[2] = aa;
        workItem.mLabels[3] = ret->mLabels;

        if (workItem.mLabels[0]->size() != workItem.mLabels[1]->size() ||
            workItem.mLabels[0]->size() != workItem.mLabels[3]->size())
            throw std::runtime_error("IfElse must be performed with variables of the same bit length. " LOCATION);
        if (workItem.mLabels[2]->size()!= 1)
            throw std::runtime_error(LOCATION);

        workItem.mCircuit = mRt.mLibrary.int_int_multiplex(workItem.mLabels[0]->size());

        mRt.enqueue(std::move(workItem));

        return rret;
    }
ObjectMemoryDeferFree::~ObjectMemoryDeferFree()
{    
    setShouldExitAndWait(); // the thread clears the queues
    //<-- something could happen here on another thread but we should be shut down by now..?
    getMemory().resetUserData();
    getMemory().resetFunctions(); 
    delete queue;
}
Beispiel #6
0
void Assoc::setPointer(const char *id, void *data)
{
	unsigned idx = getIndex(id);
	entry *e = (entry *)getMemory(sizeof(entry));
	e->id = (const char *)getMemory(strlen(id) + 1);
	strcpy((char *)e->id, id);
	e->data = data;
	e->next = entries[idx];
	entries[idx] = e;
}
Beispiel #7
0
	TEST_F(ListTest, CanCreateListWithCapacity)
	{
		auto list = new Utils::List<FooMock>(getMemory(), listCapacity);

		EXPECT_NE(nullptr, list);
		EXPECT_EQ(list->capacity(), listCapacity);
		EXPECT_EQ(sizeof(FooMock) * listCapacity, getMemory().getAllocationSize(list->begin()));

		delete list;
	}
Beispiel #8
0
	TEST_F(ListTest, CanAddItemToList)
	{
		auto list = new Utils::List<FooMock>(getMemory(), listCapacity);

		list->emplace();

		EXPECT_EQ(1, list->size());
		EXPECT_EQ(sizeof(FooMock) * list->capacity(), getMemory().getAllocationSize(list->begin()));

		delete list;
	}
ObjectMemoryDeferFree::ObjectMemoryDeferFree (Memory& m) throw()
:   ObjectMemoryBase (m),
    Threading::Thread ("Memory Deferred Free Thread")
{
    setPriority (0);
    
    getMemory().resetUserData();
    getMemory().resetFunctions();
    
    AtomicOps::memoryBarrier();
    queue = new LockFreeQueue<Element>;
    AtomicOps::memoryBarrier();
    
    getMemory().setUserData (this);
    getMemory().setFunctions (staticAlloc, staticFree); 
}
Beispiel #10
0
int main(int argc, char *argv[])
{
    int *memAddr;
    int semID;

    if(argc != 3) {
        printf("You have to pass pathname and ID!\n");
        exit(EXIT_FAILURE);
    }

    key_t key = ftok(argv[1], atoi(argv[2]));
    if(key < 0) {
        printf("Error while creating a key!\n");
        exit(EXIT_FAILURE);
    }
    memAddr = getMemory(key, 0);

    if((semID = semget(key, SEMVALUE, 0)) == -1) {
        printf("Error while getting semID!\n");
        exit(EXIT_FAILURE);
    }

    consume(memAddr, semID);
    return EXIT_SUCCESS;
}
bool JdbcUtil::removeMemory(void)
{
	setError(NULL);

	if (!getMemory(false))
	{
		// If not found, it does not exist
		if (errorCode == ENOENT) return true;
		return false;
	}

	// deactivate the old memory in case some still has it attached
	if (attachMemory())
	{
		sharedMemory->active = false;
		detachMemory();
	}

	// Remove the memory
	if (shmctl(sharedMemoryId,IPC_RMID,NULL)==-1)
	{
		setPerror("Cannot remove shared memory");
		return false;
	}
	sharedMemoryId = -1;
	return true;
}
bool JdbcUtil::attachMemory(void)
{
	setError(NULL);

	// If we have not accessed the memory, get it
	//   only if it has already been created.
	if ((sharedMemoryId==-1) &&
	    !getMemory(false)) return false;

	if (sharedMemory && !sharedMemory->active)
	{
		// We are attached to an old memory segment.
		// Detach it so we can attach the new one.
		if (!detachMemory()) return false;
	}

	if (sharedMemory==NULL)
	{
		// At this point we have an id to the memory, now we
		//   can attach it.
		void *shm;
		if ((shm = shmat(sharedMemoryId, NULL, 0)) == (void *) -1)
		{
			setPerror("Cannot attach shared memory");
			return false;
		}
		sharedMemory = (struct JdbcUtilMemoryStruct *) shm;
	}
	return true;
}
void channelDisplay::drawArray() {
	ofPushMatrix();
	ofTranslate(ax,ay,0);

	float mx = (float) aw / (float) (len-1);
	float my = (float) ah / 1.0f;

	ofFill();
	ofSetColor(255,0,0);
	ofBeginShape();
	ofVertex(0,ah);

	for(int i=0; i<len; i++) {
		ofVertex(i*mx, ah-getMemory(i)*my);
	}

	ofVertex((len-1)*mx,ah);
	ofEndShape();

	// draw outline
	ofSetColor(0,0,0);
	ofNoFill();
	ofRect(0,0,aw,ah);

	ofPopMatrix();
}
Beispiel #14
0
	TEST_F(ListTest, CanRemoveItemFromList)
	{
		auto list = new Utils::List<FooMock>(getMemory(), listCapacity);

		list->emplace();

		EXPECT_EQ(1, list->size());
		EXPECT_CALL((*list)[0], Die());

		list->eraseAt(0);

		EXPECT_EQ(0, list->size());
		EXPECT_EQ(sizeof(FooMock) * list->capacity(), getMemory().getAllocationSize(list->begin()));

		delete list;
	}
void*
UI_Memtools::getClearedMemory( unsigned long size )
{
	void *ptr;
	ptr = getMemory(size);
	memset(ptr, 0, size);
	return ptr;
}
Beispiel #16
0
void* IMemory::pointer() const {
    ssize_t offset;
    sp<IMemoryHeap> heap = getMemory(&offset);
    void* const base = heap!=0 ? heap->base() : MAP_FAILED;
    if (base == MAP_FAILED)
        return 0;
    return static_cast<char*>(base) + offset;
}
Beispiel #17
0
	TEST_F(ListTest, CanCreateList)
	{
		auto list = new Utils::List<FooMock>(getMemory());

		EXPECT_NE(nullptr, list);

		delete list;
	}
void main()
{
	// inintilizillig the matrics
	int i,j,k,tid;
	double sum = 0;
	GetArray();
	inputMatrix_T = getMemory(ArraySize);
	outputMatrix = getMemory(ArraySize);
	
	/* Loop for the generate transpose of matrix */
	#pragma omp parallel for num_threads(NUM_THREADS) shared(inputMatrix,inputMatrix_T) private(i,j)
	for(i=0;i<ArraySize;i++) { 
		for(j=0;j<ArraySize;j++){ 
			inputMatrix_T[i][j] = inputMatrix[j][i]; 
		} 
	}
	
	/* Timer Start */
	start();
	/* Matrix Multipication loop */
	#pragma omp parallel for num_threads(NUM_THREADS) \
	shared(inputMatrix,inputMatrix_T,outputMatrix,ArraySize) \
	private(i,j,k) reduction(+:sum)
	for (i=0;i<ArraySize;i++)	{
		for (j=0;j<ArraySize;j++)
		{
			//#pragma omp parallel private(i) num_threads(4)
			sum = 0; // outputMatrix[i][j]=0;
			for (k=0;k<ArraySize;k++)
			{
				sum += inputMatrix[i][k]*inputMatrix_T[j][k];
			}
			outputMatrix[i][j] = sum;
			//printf("outputMatrix[%d][%d] %d \n",i,j,outputMatrix[i][j]);
		}
	}
	/* Timer Stop */
	stop();
	write_output("parallel_output.csv");
	free(outputMatrix);
	free(inputMatrix);
	free(inputMatrix_T);
}
TEST_F(MemoryParserTestFixture, testFillMemoryStruct){
    auto memoryParser = std::make_unique<MemoryParser>(console);
    Memory * memory = memoryParser->getMemory();
    
    //grep MemTotal /proc/meminfo | awk '{print $2}'  
    EXPECT_LT(memory->total, 8090000); // >=
    EXPECT_GE(memory->total, 8000000); // <=?
    EXPECT_GE(memory->total, memory->used); // >=
    EXPECT_GT(memory->total, memory->free); // >
}
Beispiel #20
0
void Kernel::loadBootProcess(BootImage *image, Address imagePAddr, Size index)
{
    Address imageVAddr = (Address) image, args, vaddr;
    Size args_size = ARGV_SIZE;
    BootSymbol *program;
    BootSegment *segment;
    Process *proc;
    Arch::Memory local(0, Kernel::instance->getMemory());

    // Point to the program and segments table
    program = &((BootSymbol *) (imageVAddr + image->symbolTableOffset))[index];
    segment = &((BootSegment *) (imageVAddr + image->segmentsTableOffset))[program->segmentsOffset];

    // Ignore non-BootProgram entries
    if (program->type != BootProgram)
        return;

    // Create process
    proc = m_procs->create(program->entry);
    proc->setState(Process::Ready);

    if (!proc->getPageDirectory())
        return;

    // Obtain process memory
    Arch::Memory mem(proc->getPageDirectory(), getMemory());

    // Map program segment into it's virtual memory
    for (Size i = 0; i < program->segmentsCount; i++)
    {
        for (Size j = 0; j < segment[i].size; j += PAGESIZE)
        {
            mem.map(imagePAddr + segment[i].offset + j,
                    segment[i].virtualAddress + j,
                    Arch::Memory::Present  |
                    Arch::Memory::User     |
                    Arch::Memory::Readable |
                    Arch::Memory::Writable |
                    Arch::Memory::Executable);
        }
    }
    
    // Map program arguments into the process
    m_memory->allocate(&args_size, &args);
    mem.map(args, ARGV_ADDR, Arch::Memory::Present | Arch::Memory::User | Arch::Memory::Readable | Arch::Memory::Writable);

    // Copy program arguments
    vaddr = local.findFree(ARGV_SIZE, Memory::KernelPrivate);
    local.map(args, vaddr, Memory::Present|Memory::Readable|Memory::Writable);
    MemoryBlock::copy((char *)vaddr, program->name, ARGV_SIZE);

    // Done
    NOTICE("loaded: " << program->name);
}
Beispiel #21
0
	TEST_F(ListTest, CanAddManyItemsToList)
	{
		auto list = new Utils::List<int>(getMemory());

		for(int i = 0; i < listCapacity; i++)
			list->add(i);

		EXPECT_EQ(list->size(), listCapacity);
		EXPECT_LE(list->size(), list->capacity());

		delete list;
	}
void test_c64_vice_get_memory(void**)
{
    const uint8_t read_memory[] = { 0xa9, 0x22, 0xa2, 0x32, 0xc8, 0xee, 0x20, 0xd0, 0xee, 0x21, 0xd0, 0x4c, 0x0e, 0x08 };
    uint8_t dest[sizeof(read_memory) + 1];
    int dataSize = 0;

	assert_true(getMemory(dest, &dataSize, 0x080e, 14)); 

	assert_true(dataSize >= 14);

	assert_memory_equal(dest, read_memory, sizeof_array(read_memory));
}
Beispiel #23
0
    sIntBasePtr ShGcInt::gt(sIntBasePtr& a, sIntBasePtr & b)
    {
        auto aa = getMemory(a);
        auto bb = getMemory(b);
        auto ret(new ShGcInt(mRt, 1));

        ShGc::CircuitItem workItem;
        workItem.mInputBundleCount = 2;
        workItem.mLabels.resize(3);
        workItem.mLabels[0] = bb;
        workItem.mLabels[1] = aa;
        workItem.mLabels[2] = ret->mLabels;

        workItem.mCircuit = mRt.mLibrary.int_int_lt(
            workItem.mLabels[0]->size(),
            workItem.mLabels[1]->size());

        mRt.enqueue(std::move(workItem));

        return sIntBasePtr(ret);
    }
Beispiel #24
0
void printMemory(struct Processor *proc, char **tokens) {
  int start = 0;
  int end = MEMORY_SIZE;
  if (checkIfAllMemoryLocationsAreValid(tokens+1)) {
    printInvalidCommandMessage();
    return;
  }
  if (strcmp(tokens[0],"-r")) {
    start = atoi(tokens[1]);
    end = atoi(tokens[2]);
    if (start>end) {
      printInvalidCommandMessage();
      return;
    }
    if (tokens[4]!=NULL) {
       printInvalidCommandMessage();
       return;
    }
  } else if (strcmp(tokens[0],"-m")) {
    int j=0;
    while (*tokens) {
      printf("M%i=%i  ",atoi(*tokens),getMemory(proc,atoi(*tokens)));
      tokens++;
      j++;
      if (j%8==0) printf("\n");
    }
  } else if (strcmp(tokens[0],"-a")!=0) {
    printInvalidCommandMessage();
    return;
  }
  
  for (int c=start; c<start/8 ; c++) {
    for (int d=0;d<8 ;d++) {
      printf("M%i=%i  ",(c*d) +d,getMemory(proc,atoi(*tokens)));
    }
    printf("\n");
  }
  
}
Beispiel #25
0
    sIntBasePtr ShGcInt::neq(sIntBasePtr& a, sIntBasePtr & b)
    {
        if (a->bitCount() != b->bitCount())
            throw std::runtime_error("mixed bit count eq not impl. " LOCATION);

        auto aa = getMemory(a);
        auto bb = getMemory(b);
        auto ret(new ShGcInt(mRt, 1));

        ShGc::CircuitItem workItem;
        workItem.mInputBundleCount = 2;
        workItem.mLabels.resize(3);
        workItem.mLabels[0] = aa;
        workItem.mLabels[1] = bb;
        workItem.mLabels[2] = ret->mLabels;

        workItem.mCircuit = mRt.mLibrary.int_neq(
            workItem.mLabels[0]->size());

        mRt.enqueue(std::move(workItem));

        return sIntBasePtr(ret);
    }
Beispiel #26
0
    virtual void newChild(const std::shared_ptr<Poco::Net::WebSocket> &socket) override
    {
        _childSockets.push_back(socket);
        if (_childSockets.size() > NumToPrefork)
        {
            Poco::Timestamp::TimeDiff elapsed = _startTime.elapsed();

            auto totalTime = (1000. * elapsed)/Poco::Timestamp::resolution();
            Log::info() << "Launched " << _childSockets.size() << " in "
                        << totalTime << Log::end;
            size_t totalPSSKb = 0;
            size_t totalDirtyKb = 0;
            // Skip the last one as it's not completely initialized yet.
            for (size_t i = 0; i < _childSockets.size() - 1; ++i)
            {
                Log::info() << "Getting memory of child #" << i + 1 << " of " << _childSockets.size() << Log::end;
                if (!getMemory(_childSockets[i], totalPSSKb, totalDirtyKb))
                {
                    exitTest(TestResult::TEST_FAILED);
                    return;
                }
            }

            Log::info() << "Memory use total   " << totalPSSKb << "k shared "
                        << totalDirtyKb << "k dirty" << Log::end;

            totalPSSKb /= _childSockets.size();
            totalDirtyKb /= _childSockets.size();
            Log::info() << "Memory use average " << totalPSSKb << "k shared "
                        << totalDirtyKb << "k dirty" << Log::end;

            Log::info() << "Launch time total   " << totalTime << " ms" << Log::end;
            totalTime /= _childSockets.size();
            Log::info() << "Launch time average " << totalTime << " ms" << Log::end;

            if (!_failure.empty())
            {
                Log::error("UnitPrefork failed due to: " + _failure);
                exitTest(TestResult::TEST_FAILED);
            }
            else
            {
                Log::error("UnitPrefork success.");
                exitTest(TestResult::TEST_OK);
            }
        }
    }
Beispiel #27
0
status_t BnMemory::onTransact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    switch(code) {
        case GET_MEMORY: {
            CHECK_INTERFACE(IMemory, data, reply);
            ssize_t offset;
            size_t size;
            reply->writeStrongBinder( getMemory(&offset, &size)->asBinder() );
            reply->writeInt32(offset);
            reply->writeInt32(size);
            return NO_ERROR;
        } break;
        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
}
Position PathMemory::moveOnPath(Position current, Position next, Position end)
{
	if (!currentPath)
	{
		if (existsPath(current, end))
		{
			currentPath = getMemory(current, end);
		}
		else
		{
			startPath(current, end);
		}
	}
	else
	{
		if (current == end)
		{
			currentPath->path.push_back(current);
			currentPath->pathComplete = true;
			currentPath = NULL;
			return current;
		}
		if (currentPath->pathComplete)
		{
			return getPrevPosition();
		}
		else if (pathMap[next] == VISITED)
		{
			pathMap[current] = VISITED;
			if (currentPath->path.size() >= 2)
			{
				Position pos = *(currentPath->path.end() - 1);
				currentPath->path.erase(currentPath->path.end() - 1);
				return pos;
			}
			return currentPath->start;
		}
		else
		{
			currentPath->path.push_back(current);
			pathMap[current] = VISITED;
			return next;
		}
	}
	return next;
}
Beispiel #29
0
int main(int argc, char **argv) {
	int rv = getMemory();

	if(rv == OSMP_ERROR) {
		printf("Fehler beim Laden des Shared Memorys! Grund: %s", strerror(errno));
		return OSMP_ERROR;
	}

	int value = 10;

	while(value == 10) {
		printMemory();
		value = getchar();
		fflush(stdin);
	}
	return 1;
}
void Timer::step (std::string text)
{
    stopTime();
    stopMemory();

    clock_t clickNb = eTime - iTime;
    time = ((float)clickNb)/CLOCKS_PER_SEC;
    memory = eMemory - iMemory;

    if (text != "") {
        std::cout << text << ": ";
    }
    std::cout << "STEP TIMER " << id << " (" << time << " sec, " << memory << " bytes)" << std::endl;

    iTime = clock();
    iMemory = getMemory();
}