TEST(MemoryMapping, DoublyMapped) {
File f = File::temporary();
// two mappings of the same memory, different addresses.
MemoryMapping mw(File(f.fd()), 0, sizeof(double), MemoryMapping::writable());
MemoryMapping mr(File(f.fd()), 0, sizeof(double));
double* dw = mw.asWritableRange<double>().data();
const double* dr = mr.asRange<double>().data();
// Show that it's truly the same value, even though the pointers differ
EXPECT_NE(dw, dr);
*dw = 42 * kSomeDouble;
EXPECT_EQ(*dr, 42 * kSomeDouble);
*dw = 43 * kSomeDouble;
EXPECT_EQ(*dr, 43 * kSomeDouble);
}
std::ofstream& operator<<(std::ofstream& s, const GeneralMatrix& X)
{
MatrixRow mr((GeneralMatrix*)&X, LoadOnEntry);
int w = s.width(); int nr = X.Nrows(); ios_format_flags f = s.flags();
s.setf(ios::fixed, ios::floatfield);
for (int i=1; i<=nr; i++)
{
int skip = mr.skip; int storage = mr.storage;
Real* store = mr.data; skip *= w+1;
while (skip--) s << " ";
while (storage--) { s.width(w); s << *store++ << " "; }
// while (storage--) s << setw(w) << *store++ << " ";
mr.Next(); s << ", ";
}
s << flush; s.flags(f); return s;
}
void GetSubMatrix::operator<<(const int* r)
{
REPORT
Tracer tr("SubMatrix(<<int*)");
SetUpLHS();
if (row_skip+row_number > gm->Nrows() || col_skip+col_number > gm->Ncols())
Throw(SubMatrixDimensionException());
MatrixRow mr(gm, LoadOnEntry+StoreOnExit+DirectPart, row_skip);
// do need LoadOnEntry
MatrixRowCol sub; int i = row_number;
while (i--)
{
mr.SubRowCol(sub, col_skip, col_number); // put values in sub
sub.Copy(r); mr.Next();
}
}
optional<Value> fetch_optional( const Key& k )
{ try {
auto key_path = key_to_path(k);
if( fc::exists( key_to_path ) )
{
// memmap, read, return value
fc::file_mapping fm( key_to_path.c_str(), fc::read_only );
fc::mapped_region mr( fm, fc::read_only );
const char* addr = (const char*)mr.get_address();
size_t s = mr.get_size();
datastream<const char*> ds(addr,s);
Value v;
fc::raw::unpack( ds, v );
return v;
}
return optional<Value>();
} FC_CAPTURE_AND_RETHROW( (k) ) }
void GetSubMatrix::operator=(Real r)
{
REPORT
Tracer tr("SubMatrix(=Real)");
SetUpLHS();
MatrixRow mr(gm, LoadOnEntry+StoreOnExit+DirectPart, row_skip);
// do need LoadOnEntry
MatrixRowCol sub; int i = row_number;
while (i--)
{
mr.SubRowCol(sub, col_skip, col_number); // put values in sub
sub.Copy(r); mr.Next();
}
#ifdef TEMPS_DESTROYED_QUICKLY
delete this;
#endif
}
void GetSubMatrix::inject(const GeneralMatrix& gmx)
{
REPORT
Tracer tr("SubMatrix(inject)");
SetUpLHS();
if (row_number != gmx.Nrows() || col_number != gmx.Ncols())
Throw(IncompatibleDimensionsException());
MatrixRow mrx((GeneralMatrix*)(&gmx), LoadOnEntry);
MatrixRow mr(gm, LoadOnEntry+StoreOnExit+DirectPart, row_skip);
// do need LoadOnEntry
MatrixRowCol sub; int i = row_number;
while (i--)
{
mr.SubRowCol(sub, col_skip, col_number); // put values in sub
sub.Inject(mrx); mr.Next(); mrx.Next();
}
}
PapxFKPage::PapxFKPage(DataReader& dr)
{
unsigned char pagedata[512];
dr.Read(&pagedata, 512);
m_icrun = pagedata[511];
MemoryReader vr(pagedata, m_icrun*17+4);
m_BXMap.Read(vr);
for (unsigned int i=0; i<m_BXMap.ObjectCount(); i++)
{
int iOffset = m_BXMap.ObjectAt(i).iWordPos * 2;
MemoryReader mr(pagedata + iOffset, 512 - iOffset);
m_vecPapxs.push_back(PapX(mr, false));
}
}
void ASParNewGeneration::reset_survivors_after_shrink() {
GenCollectedHeap* gch = GenCollectedHeap::heap();
HeapWord* new_end = (HeapWord*)virtual_space()->high();
if (from()->end() > to()->end()) {
assert(new_end >= from()->end(), "Shrinking past from-space");
} else {
assert(new_end >= to()->bottom(), "Shrink was too large");
// Was there a shrink of the survivor space?
if (new_end < to()->end()) {
MemRegion mr(to()->bottom(), new_end);
to()->initialize(mr,
SpaceDecorator::DontClear,
SpaceDecorator::DontMangle);
}
}
}
NS_DECL_ISUPPORTS
NS_IMETHOD Callback(const nsACString &aProcess, const nsACString &aPath,
PRInt32 aKind, PRInt32 aUnits, PRInt64 aAmount,
const nsACString &aDescription,
nsISupports *aWrappedMRs)
{
if (aKind == nsIMemoryReporter::KIND_NONHEAP &&
PromiseFlatCString(aPath).Find("explicit") == 0 &&
aAmount != PRInt64(-1)) {
MemoryReportsWrapper *wrappedMRs =
static_cast<MemoryReportsWrapper *>(aWrappedMRs);
MemoryReport mr(aPath, aAmount);
wrappedMRs->mReports->AppendElement(mr);
}
return NS_OK;
}
static void do_command(char *c)
{
char *token;
token = get_token(&c);
if(strcmp(token, "mr") == 0) mr(get_token(&c), get_token(&c));
else if(strcmp(token, "mw") == 0) mw(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "mc") == 0) mc(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "crc") == 0) crc(get_token(&c), get_token(&c));
else if(strcmp(token, "flushl2") == 0) flush_l2_cache();
#ifdef FLASH_BOOT_ADDRESS
else if(strcmp(token, "flashboot") == 0) flashboot();
#endif
else if(strcmp(token, "serialboot") == 0) serialboot();
#ifdef MINIMAC_BASE
else if(strcmp(token, "netboot") == 0) netboot();
#endif
else if(strcmp(token, "revision") == 0) printf("%08x\n", MSC_GIT_ID);
else if(strcmp(token, "help") == 0) help();
else if(strcmp(token, "rcsr") == 0) rcsr(get_token(&c));
else if(strcmp(token, "wcsr") == 0) wcsr(get_token(&c), get_token(&c));
#ifdef DFII_BASE
else if(strcmp(token, "ddrrow") == 0) ddrrow(get_token(&c));
else if(strcmp(token, "ddrsw") == 0) ddrsw();
else if(strcmp(token, "ddrhw") == 0) ddrhw();
else if(strcmp(token, "ddrrd") == 0) ddrrd(get_token(&c));
else if(strcmp(token, "ddrwr") == 0) ddrwr(get_token(&c));
else if(strcmp(token, "memtest") == 0) memtest();
else if(strcmp(token, "ddrinit") == 0) ddrinit();
#endif
else if(strcmp(token, "dfs") == 0) dfs(get_token(&c));
else if(strcmp(token, "") != 0)
printf("Command not found\n");
}
static void do_command(char *c)
{
char *token;
token = get_token(&c);
if(strcmp(token, "mr") == 0) mr(get_token(&c), get_token(&c));
else if(strcmp(token, "mw") == 0) mw(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "mc") == 0) mc(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "crc") == 0) crc(get_token(&c), get_token(&c));
else if(strcmp(token, "serialboot") == 0) serialboot();
else if(strcmp(token, "reboot") == 0) reboot();
else if(strcmp(token, "help") == 0) help();
else if(strcmp(token, "") != 0)
printf("Command not found\n");
}
void Camera::Rotate(float angle,vec3 axis)
{
mat34 mr(cos(angle),sin(angle),axis);
nav = mr.MultRot(nav);
top = mr.MultRot(top);
left = mr.MultRot(left);
//для избавления от накапливающейся погрешности
static int cnt=100;
cnt--;
if(!cnt)
{
cnt=100;
nav.normalize();
left = left.proected_on(nav).normalized();
top = vec3::vect_mult(left,nav);
}
UpdatePos();
}
void operator () (int runs, fast_tag) const {
try {
static M m (N, N);
ublas::matrix_range<M> mr (m, ublas::range (0, N), ublas::range (0, N));
static V v1 (N), v2 (N);
ublas::vector_range<V> vr1 (v1, ublas::range (0, N)),
vr2 (v2, ublas::range (0, N));
initialize_vector (vr1);
initialize_vector (vr2);
boost::timer t;
for (int i = 0; i < runs; ++ i) {
mr.assign (- ublas::outer_prod (vr1, vr2));
// sink_matrix (mr);
}
footer<value_type> () (N * N, N * N, runs, t.elapsed ());
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
}
void GetSubMatrix::operator=(const BaseMatrix& bmx)
{
REPORT
Tracer tr("SubMatrix(=)"); GeneralMatrix* gmx = 0;
// MatrixConversionCheck mcc; // Check for loss of info
Try
{
SetUpLHS(); gmx = ((BaseMatrix&)bmx).Evaluate();
if (row_number != gmx->Nrows() || col_number != gmx->Ncols())
Throw(IncompatibleDimensionsException());
LoadAndStoreFlag lasf =
( row_skip == col_skip
&& gm->Type().IsSymmetric()
&& gmx->Type().IsSymmetric() )
? LoadOnEntry+DirectPart
: LoadOnEntry;
MatrixRow mrx(gmx, lasf);
MatrixRow mr(gm, LoadOnEntry+StoreOnExit+DirectPart, row_skip);
// do need LoadOnEntry
MatrixRowCol sub; int i = row_number;
while (i--)
{
mr.SubRowCol(sub, col_skip, col_number); // put values in sub
sub.CopyCheck(mrx); mr.Next(); mrx.Next();
}
gmx->tDelete();
#ifdef TEMPS_DESTROYED_QUICKLY
delete this;
#endif
}
CatchAll
{
if (gmx) gmx->tDelete();
#ifdef TEMPS_DESTROYED_QUICKLY
delete this;
#endif
ReThrow;
}
}
JNIEXPORT void JNICALL
Java_org_apache_subversion_javahl_SVNRepos_lstxns
(JNIEnv *env, jobject jthis, jobject jpath, jobject jmessageReceiver)
{
JNIEntry(SVNRepos, lstxns);
SVNRepos *cl = SVNRepos::getCppObject(jthis);
if (cl == NULL)
{
JNIUtil::throwError(_("bad C++ this"));
return;
}
File path(jpath);
if (JNIUtil::isExceptionThrown())
return;
MessageReceiver mr(jmessageReceiver);
if (JNIUtil::isExceptionThrown())
return;
cl->lstxns(path, mr);
}
bool Test::test_mazeReader06()
{
bool isPassed = false;
std::string testFileName = "maze.txt";
const int correctRows = 5;
const int correctCols = 4;
m_testNum++;
printTestMessage(m_testNum, "MazeReader getStartRow and getStartCol return correct values on valid maze");
if(isFileAccessible(testFileName))
{
try
{
MazeReader mr(testFileName);
if( (correctRows == mr.getStartRow()) && (correctCols == mr.getStartCol()) )
{
isPassed = true;
}
else
{
std::cerr << "ERROR: expected " << correctRows << " and " << correctCols
<< " got " << mr.getStartRow() << " and " << mr.getStartCol() << std::endl;
}
}
catch(...)
{
std::cerr << "ERROR: exception thrown with valid file" << std::endl;
}
}
else
{
std::cerr << "ERROR " << testFileName << " not accessible. Place in lab folder." << std::endl;
}
printPassFail(isPassed);
return(isPassed);
}
void PSYoungGen::reset_survivors_after_shrink() {
_reserved = MemRegion((HeapWord*)virtual_space()->low_boundary(),
(HeapWord*)virtual_space()->high_boundary());
PSScavenge::reference_processor()->set_span(_reserved);
MutableSpace* space_shrinking = NULL;
if (from_space()->end() > to_space()->end()) {
space_shrinking = from_space();
} else {
space_shrinking = to_space();
}
HeapWord* new_end = (HeapWord*)virtual_space()->high();
assert(new_end >= space_shrinking->bottom(), "Shrink was too large");
// Was there a shrink of the survivor space?
if (new_end < space_shrinking->end()) {
MemRegion mr(space_shrinking->bottom(), new_end);
space_shrinking->initialize(mr,
SpaceDecorator::DontClear,
SpaceDecorator::Mangle);
}
}
void GetSubMatrix::operator*=(Real r)
{
REPORT
Tracer tr("SubMatrix(*= or /= Real)");
// MatrixConversionCheck mcc; // Check for loss of info
Try
{
SetUpLHS();
MatrixRow mr(gm, LoadOnEntry+StoreOnExit+DirectPart, row_skip);
// do need LoadOnEntry
MatrixRowCol sub; int i = row_number;
while (i--)
{
mr.SubRowCol(sub, col_skip, col_number); // put values in sub
sub.Multiply(r); mr.Next();
}
}
CatchAll
{
ReThrow;
}
}
void operator () (int runs, safe_tag) const {
try {
static M m (N, N);
ublas::matrix_range<M> mr (m, ublas::range (0, N), ublas::range (0, N));
static V v1 (N), v2 (N);
ublas::vector_range<V> vr1 (v1, ublas::range (0, N)),
vr2 (v2, ublas::range (0, N));
initialize_matrix (mr);
initialize_vector (vr1);
boost::timer t;
for (int i = 0; i < runs; ++ i) {
vr2 = ublas::prod (mr, vr1);
// sink_vector (vr2);
}
footer<value_type> () (N * N, N * (N - 1), runs, t.elapsed ());
}
catch (std::exception &e) {
std::cout << e.what () << std::endl;
}
catch (...) {
std::cout << "unknown exception" << std::endl;
}
}
void
MinimalTIFFWriter::setId(const boost::filesystem::path& id)
{
FormatWriter::setId(id);
std::string flags("w");
// Get expected size of pixel data.
ome::compat::shared_ptr<const ::ome::xml::meta::MetadataRetrieve> mr(getMetadataRetrieve());
storage_size_type pixelSize = significantPixelSize(*mr);
if (enableBigTIFF(bigTIFF, pixelSize, *currentId, logger))
flags += '8';
tiff = TIFF::open(id, flags);
ifd = tiff->getCurrentDirectory();
setupIFD();
// Create IFD mapping from metadata.
MetadataRetrieve::index_type imageCount = metadataRetrieve->getImageCount();
dimension_size_type currentIFD = 0U;
for (MetadataRetrieve::index_type i = 0;
i < imageCount;
++i)
{
dimension_size_type planeCount = getImageCount();
tiff::IFDRange range;
range.filename = *currentId;
range.begin = currentIFD;
range.end = currentIFD + planeCount;
seriesIFDRange.push_back(range);
currentIFD += planeCount;
}
}
void Hold::SetupIKConstraint(const Vector3& localPos0, const Vector3& rot)
{
ikConstraint.link = link;
Assert(!contacts.empty());
ikConstraint.localPosition = localPos0;
ikConstraint.SetFixedPosition(contacts[0].x);
//any rotation constraints?
if(contacts.size()==1) { //point contact
ikConstraint.SetFreeRotation();
ikConstraint.endRotation = rot;
}
else if(contacts.size()==2) { //line contact
//cout<<"Setting edge rotation example moment "<<rot<<endl;
Vector3 axis = contacts[1].x-contacts[0].x;
if(axis.normSquared()==0) { //degenerate, point contact
//cout<<"Warning: degenerate point contact"<<endl;
ikConstraint.SetFreeRotation();
ikConstraint.endRotation = rot;
return;
}
MomentRotation mr(rot);
Matrix3 R;
mr.getMatrix(R);
R.inplaceTranspose();
axis.inplaceNormalize();
//cout<<"world-space rotation axis: "<<axis<<endl;
//cout<<"local-space rotation axis: "<<R*axis<<endl;
ikConstraint.SetAxisRotation(R*axis,axis);
}
else { //plane contact
ikConstraint.SetFixedRotation(rot);
}
}
bool OneContigSpaceCardGeneration::grow_by(size_t bytes) {
assert_locked_or_safepoint(ExpandHeap_lock);
bool result = _virtual_space.expand_by(bytes);
if (result) {
size_t new_word_size =
heap_word_size(_virtual_space.committed_size());
MemRegion mr(_the_space->bottom(), new_word_size);
// Expand card table
Universe::heap()->barrier_set()->resize_covered_region(mr);
// Expand shared block offset array
_bts->resize(new_word_size);
// Fix for bug #4668531
if (ZapUnusedHeapArea) {
MemRegion mangle_region(_the_space->end(),
(HeapWord*)_virtual_space.high());
SpaceMangler::mangle_region(mangle_region);
}
// Expand space -- also expands space's BOT
// (which uses (part of) shared array above)
_the_space->set_end((HeapWord*)_virtual_space.high());
// update the space and generation capacity counters
update_counters();
if (Verbose && PrintGC) {
size_t new_mem_size = _virtual_space.committed_size();
size_t old_mem_size = new_mem_size - bytes;
gclog_or_tty->print_cr("Expanding %s from " SIZE_FORMAT "K by "
SIZE_FORMAT "K to " SIZE_FORMAT "K",
name(), old_mem_size/K, bytes/K, new_mem_size/K);
}
}
return result;
}
void mime_test()
{
{
mime_part m1( "text", "plain" );
m1.add_content_type_param( "charset", "utf-8" );
m1.add_header( "Content-Transfer-Encoding", "7bit" );
m1.set_body( "body." );
std::string data = m1.get();
printf( "%s\ndone.\n", data.c_str() );
}
{
mime_part mr( "multipart", "mixed" );
mime_part m0( "multipart", "mixed" );
mr.append_part( &m0 );
mime_part m1( "text", "plain" );
m1.add_content_type_param( "charset", "utf-8" );
m1.add_header( "Content-Transfer-Encoding", "7bit" );
m1.set_body( "body." );
mime_part m2( "application", "x-msdownload" );
m2.add_content_type_param( "name", "abcd.data" );
m2.add_header( "Content-Transfer-Encoding", "base64" );
m2.add_header( "Content-Disposition", "attachment" );
m2.add_content_type_param( "filename", "abcd.data" );
m2.set_body( "lalajsdflajdlfkjadlkfjaldkfjladjflakdjflakdjflakjdflajdsflajdlfkajdlfkjaldkfjalkdjflakdjsflkasdjflasd" );
m0.append_part( &m1 );
m0.append_part( &m2 );
std::string data = mr.get();
printf( "\n%s\ndone.\n", data.c_str() );
}
}
static void do_command(char *c)
{
char *token;
token = get_token(&c);
if(strcmp(token, "cons") == 0) vga_set_console(!vga_get_console());
else if(strcmp(token, "flush") == 0) flush_bridge_cache();
else if(strcmp(token, "mr") == 0) mr(get_token(&c), get_token(&c));
else if(strcmp(token, "mw") == 0) mw(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "mc") == 0) mc(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "crc") == 0) crc(get_token(&c), get_token(&c));
else if(strcmp(token, "ls") == 0) ls(get_token(&c));
else if(strcmp(token, "load") == 0) load(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "netboot") == 0) netboot();
else if(strcmp(token, "serialboot") == 0) serialboot();
else if(strcmp(token, "fsboot") == 0) fsboot(BLOCKDEV_MEMORY_CARD);
else if(strcmp(token, "flashboot") == 0) flashboot();
else if(strcmp(token, "mdior") == 0) mdior(get_token(&c));
else if(strcmp(token, "mdiow") == 0) mdiow(get_token(&c), get_token(&c));
else if(strcmp(token, "version") == 0) puts(VERSION);
else if(strcmp(token, "reboot") == 0) reboot();
else if(strcmp(token, "reconf") == 0) reconf();
else if(strcmp(token, "help") == 0) help();
else if(strcmp(token, "rcsr") == 0) rcsr(get_token(&c));
else if(strcmp(token, "wcsr") == 0) wcsr(get_token(&c), get_token(&c));
else if(strcmp(token, "") != 0)
printf("Command not found\n");
}
bool Model::load( unsigned char * _buffer, size_t _size )
{
size_t read = 0;
stdex::memory_reader mr( _buffer, _size, read );
mr << m_frameCount;
mr << m_vertexCount;
mr << m_indicesCount;
mr << m_frameDelay;
mr << m_cameraFOV;
mr << m_cameraWidth;
mr << m_cameraHeight;
m_model3DFrames = new Model3DFrame[ m_frameCount ];
for( uint32_t i = 0; i != m_frameCount; ++i )
{
Model3DFrame & frame = m_model3DFrames[ i ];
mr << frame.cameraRight;
mr << frame.cameraUp;
mr << frame.cameraDir;
mr << frame.cameraPos;
frame.pos = new mt::vec3f[m_vertexCount];
frame.uv = new mt::vec2f[m_vertexCount];
frame.indecies = new uint16_t[m_indicesCount];
mr.readPODs( frame.pos, m_vertexCount );
mr.readPODs( frame.uv, m_vertexCount );
mr.readPODs( frame.indecies, m_indicesCount );
}
uint16_t width;
uint16_t height;
mr << width;
mr << height;
if( width != 0 && height != 0 )
{
if( isTexturePOW2( width ) == false || isTexturePOW2( height ) == false )
{
//_logger.message( "Model::load invalid texture POW2 %d:%d please set texture %d:%d"
// , width
// , height
// , getTexturePOW2( width )
// , getTexturePOW2( height )
// );
return false;
}
LPDIRECT3DTEXTURE9 texture = NULL;
if( m_pDevice->CreateTexture( width, height, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, NULL ) != D3D_OK )
{
//_logger.message( "Model::load invalid create texture %d:%d"
// , width
// , height
// );
return false;
}
D3DLOCKED_RECT lockedRect;
DXCALL texture->LockRect( 0, &lockedRect, NULL, 0 );
if( lockedRect.pBits == NULL || lockedRect.Pitch == 0 )
{
//_logger.message( "Model::load invalid lock texture %d:%d"
// , width
// , height
// );
return false;
}
for( uint16_t i = 0; i != height; ++i )
{
unsigned char * bits = static_cast<unsigned char *>(lockedRect.pBits) + lockedRect.Pitch * i;
mr.readPODs( bits, width * 4 );
}
DXCALL texture->UnlockRect( 0 );
m_pTexture = texture;
}
else
{
m_pTexture = NULL;
}
return true;
}
void CFAProxy::ListDrives()
{
CListDrivesMR::TCallback f = boost::bind( &CFAManager::cmListDrives , m_pManager , _1 ,_2 );
CScheduler::TMethod mr( CScheduler::TMethod( new CListDrivesMR( m_pFAClient ,f ) ) );
m_scheduler.AddMethod( mr );
}
address generate_call_stub(address& return_address)
{
assert (!TaggedStackInterpreter, "not supported");
StubCodeMark mark(this, "StubRoutines", "call_stub");
address start = __ enter();
const Register call_wrapper = r3;
const Register result = r4;
const Register result_type = r5;
const Register method = r6;
const Register entry_point = r7;
const Register parameters = r8;
const Register parameter_words = r9;
const Register thread = r10;
#ifdef ASSERT
// Make sure we have no pending exceptions
{
StackFrame frame;
Label label;
__ load (r0, Address(thread, Thread::pending_exception_offset()));
__ compare (r0, 0);
__ beq (label);
__ prolog (frame);
__ should_not_reach_here (__FILE__, __LINE__);
__ epilog (frame);
__ blr ();
__ bind (label);
}
#endif // ASSERT
// Calculate the frame size
StackFrame frame;
for (int i = 0; i < StackFrame::max_crfs; i++)
frame.get_cr_field();
for (int i = 0; i < StackFrame::max_gprs; i++)
frame.get_register();
StubRoutines::set_call_stub_base_size(frame.unaligned_size() + 3*wordSize);
// the 3 extra words are for call_wrapper, result and result_type
const Register parameter_bytes = parameter_words;
__ shift_left (parameter_bytes, parameter_words, LogBytesPerWord);
const Register frame_size = r11;
const Register padding = r12;
__ addi (frame_size, parameter_bytes, StubRoutines::call_stub_base_size());
__ calc_padding_for_alignment (padding, frame_size, StackAlignmentInBytes);
__ add (frame_size, frame_size, padding);
// Save the link register and create the new frame
__ mflr (r0);
__ store (r0, Address(r1, StackFrame::lr_save_offset * wordSize));
__ neg (r0, frame_size);
__ store_update_indexed (r1, r1, r0);
#ifdef PPC64
__ mfcr (r0);
__ store (r0, Address(r1, StackFrame::cr_save_offset * wordSize));
#endif // PPC64
// Calculate the address of the interpreter's local variables
const Register locals = frame_size;
__ addi (locals, r1, frame.start_of_locals() - wordSize);
__ add (locals, locals, padding);
__ add (locals, locals, parameter_bytes);
// Store the call wrapper address and the result stuff
const int initial_offset = 1;
int offset = initial_offset;
__ store (call_wrapper, Address(locals, offset++ * wordSize));
__ store (result, Address(locals, offset++ * wordSize));
__ store (result_type, Address(locals, offset++ * wordSize));
// Store the registers
#ifdef PPC32
__ mfcr (r0);
__ store (r0, Address(locals, offset++ * wordSize));
#endif // PPC32
for (int i = 14; i < 32; i++) {
__ store (as_Register(i), Address(locals, offset++ * wordSize));
}
const int final_offset = offset;
// Store the location of call_wrapper
frame::set_call_wrapper_offset((final_offset - initial_offset) * wordSize);
#ifdef ASSERT
// Check that we wrote all the way to the end of the frame.
// The frame may have been resized when we return from the
// interpreter, so the start of the frame may have moved
// but the end will be where we left it and we rely on this
// to find our stuff.
{
StackFrame frame;
Label label;
__ load (r3, Address(r1, 0));
__ subi (r3, r3, final_offset * wordSize);
__ compare (r3, locals);
__ beq (label);
__ prolog (frame);
__ should_not_reach_here (__FILE__, __LINE__);
__ epilog (frame);
__ blr ();
__ bind (label);
}
#endif // ASSERT
// Pass parameters if any
{
Label loop, done;
__ compare (parameter_bytes, 0);
__ ble (done);
const Register src = parameters;
const Register dst = padding;
__ mr (dst, locals);
__ shift_right (r0, parameter_bytes, LogBytesPerWord);
__ mtctr (r0);
__ bind (loop);
__ load (r0, Address(src, 0));
__ store (r0, Address(dst, 0));
__ addi (src, src, wordSize);
__ subi (dst, dst, wordSize);
__ bdnz (loop);
__ bind (done);
}
// Make the call
__ mr (Rmethod, method);
__ mr (Rlocals, locals);
__ mr (Rthread, thread);
__ mtctr (entry_point);
__ bctrl();
// This is used to identify call_stub stack frames
return_address = __ pc();
// Figure out where our stuff is stored
__ load (locals, Address(r1, 0));
__ subi (locals, locals, final_offset * wordSize);
#ifdef ASSERT
// Rlocals should contain the address we just calculated.
{
StackFrame frame;
Label label;
__ compare (Rlocals, locals);
__ beq (label);
__ prolog (frame);
__ should_not_reach_here (__FILE__, __LINE__);
__ epilog (frame);
__ blr ();
__ bind (label);
}
#endif // ASSERT
// Is an exception being thrown?
Label exit;
__ load (r0, Address(Rthread, Thread::pending_exception_offset()));
__ compare (r0, 0);
__ bne (exit);
// Store result depending on type
const Register result_addr = r6;
Label is_int, is_long, is_object;
offset = initial_offset + 1; // skip call_wrapper
__ load (result_addr, Address(locals, offset++ * wordSize));
__ load (result_type, Address(locals, offset++ * wordSize));
__ compare (result_type, T_INT);
__ beq (is_int);
__ compare (result_type, T_LONG);
__ beq (is_long);
__ compare (result_type, T_OBJECT);
__ beq (is_object);
__ should_not_reach_here (__FILE__, __LINE__);
__ bind (is_int);
__ stw (r3, Address(result_addr, 0));
__ b (exit);
__ bind (is_long);
#ifdef PPC32
__ store (r4, Address(result_addr, wordSize));
#endif
__ store (r3, Address(result_addr, 0));
__ b (exit);
__ bind (is_object);
__ store (r3, Address(result_addr, 0));
//__ b (exit);
// Restore the registers
__ bind (exit);
#ifdef PPC32
__ load (r0, Address(locals, offset++ * wordSize));
__ mtcr (r0);
#endif // PPC32
for (int i = 14; i < 32; i++) {
__ load (as_Register(i), Address(locals, offset++ * wordSize));
}
#ifdef PPC64
__ load (r0, Address(r1, StackFrame::cr_save_offset * wordSize));
__ mtcr (r0);
#endif // PPC64
assert (offset == final_offset, "save and restore must match");
// Unwind and return
__ load (r1, Address(r1, StackFrame::back_chain_offset * wordSize));
__ load (r0, Address(r1, StackFrame::lr_save_offset * wordSize));
__ mtlr (r0);
__ blr ();
return start;
}
// Code generation
address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler* _masm,
vmIntrinsics::ID iid) {
const bool not_for_compiler_entry = false; // this is the interpreter entry
assert(is_signature_polymorphic(iid), "expected invoke iid");
if (iid == vmIntrinsics::_invokeGeneric ||
iid == vmIntrinsics::_compiledLambdaForm) {
// Perhaps surprisingly, the symbolic references visible to Java are not directly used.
// They are linked to Java-generated adapters via MethodHandleNatives.linkMethod.
// They all allow an appendix argument.
__ stop("Should not reach here"); // empty stubs make SG sick
return NULL;
}
Register argbase = CC_INTERP_ONLY(R17_tos) NOT_CC_INTERP(R15_esp); // parameter (preserved)
Register argslot = R3;
Register temp1 = R6;
Register param_size = R7;
// here's where control starts out:
__ align(CodeEntryAlignment);
address entry_point = __ pc();
if (VerifyMethodHandles) {
Label L;
BLOCK_COMMENT("verify_intrinsic_id {");
__ load_sized_value(temp1, Method::intrinsic_id_offset_in_bytes(), R19_method,
sizeof(u1), /*is_signed*/ false);
// assert(sizeof(u1) == sizeof(Method::_intrinsic_id), "");
__ cmpwi(CCR1, temp1, (int) iid);
__ beq(CCR1, L);
if (iid == vmIntrinsics::_linkToVirtual ||
iid == vmIntrinsics::_linkToSpecial) {
// could do this for all kinds, but would explode assembly code size
trace_method_handle(_masm, "bad Method*:intrinsic_id");
}
__ stop("bad Method*::intrinsic_id");
__ BIND(L);
BLOCK_COMMENT("} verify_intrinsic_id");
}
// First task: Find out how big the argument list is.
int ref_kind = signature_polymorphic_intrinsic_ref_kind(iid);
assert(ref_kind != 0 || iid == vmIntrinsics::_invokeBasic, "must be _invokeBasic or a linkTo intrinsic");
if (ref_kind == 0 || MethodHandles::ref_kind_has_receiver(ref_kind)) {
__ ld(param_size, in_bytes(Method::const_offset()), R19_method);
__ load_sized_value(param_size, in_bytes(ConstMethod::size_of_parameters_offset()), param_size,
sizeof(u2), /*is_signed*/ false);
// assert(sizeof(u2) == sizeof(ConstMethod::_size_of_parameters), "");
} else {
DEBUG_ONLY(param_size = noreg);
}
Register tmp_mh = noreg;
if (!is_signature_polymorphic_static(iid)) {
__ ld(tmp_mh = temp1, __ argument_offset(param_size, param_size, 0), argbase);
DEBUG_ONLY(param_size = noreg);
}
if (TraceMethodHandles) {
if (tmp_mh != noreg) {
__ mr(R23_method_handle, tmp_mh); // make stub happy
}
trace_method_handle_interpreter_entry(_masm, iid);
}
if (iid == vmIntrinsics::_invokeBasic) {
generate_method_handle_dispatch(_masm, iid, tmp_mh, noreg, not_for_compiler_entry);
} else {
// Adjust argument list by popping the trailing MemberName argument.
Register tmp_recv = noreg;
if (MethodHandles::ref_kind_has_receiver(ref_kind)) {
// Load the receiver (not the MH; the actual MemberName's receiver) up from the interpreter stack.
__ ld(tmp_recv = temp1, __ argument_offset(param_size, param_size, 0), argbase);
DEBUG_ONLY(param_size = noreg);
}
Register R19_member = R19_method; // MemberName ptr; incoming method ptr is dead now
__ ld(R19_member, RegisterOrConstant((intptr_t)8), argbase);
__ add(argbase, Interpreter::stackElementSize, argbase);
generate_method_handle_dispatch(_masm, iid, tmp_recv, R19_member, not_for_compiler_entry);
}
return entry_point;
}
operator MRect()const {MRect mr(l(0), t(0), r(0), b(0)); return mr;}
Int_t main(Int_t argc, Char_t *argv[])
{
ROOT::Mpi::TEnvironment env(argc, argv);
ROOT::Mpi::TIntraCommunicator world;
// MpiInitTest(world, 2, ROOT::Mpi::GreaterIqual);
TMatrixT<Double_t> mResult;
TMatrixT<Double_t> m1(rowm1, colm1);
TMatrixT<Double_t> m2(rowm2, colm2);
TMatrixT<Double_t> m1square(side, side);
TMatrixT<Double_t> m2square(side, side);
for (Int_t i = 0; i < rowm1; i++)
for (Int_t j = 0; j < colm1; j++)
m1[i][j] = i + j;
for (Int_t i = 0; i < rowm2; i++)
for (Int_t j = 0; j < colm2; j++)
m2[i][j] = j;
for (Int_t i = 0; i < side; i++)
for (Int_t j = 0; j < side; j++) {
m1square[i][j] = j;
m2square[i][j] = i;
}
///////////////////////////////////////////////
//Testing methdos with results in single Rank//
///////////////////////////////////////////////
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mul(m1);
mul.Mult(m2, root);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> add(m1square);
add.Addition(m2square, root);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> sub(m1square);
sub.Subtraction(m2square, root);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> trans(m2);
trans.Transpose(root);
if (world.Rank() == root) {
mul.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1 * m2, world.Rank(), "Matrix Multiplication Single");
add.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square + m2square, world.Rank(), "Matrix Addition Single");
sub.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square - m2square, world.Rank(), "Matrix Subtraction Single");
trans.GetResult(mResult);
MpiCompareTMatrixTest(mResult, TMatrixT<Double_t>(m2.GetNcols(), m2.GetNrows()).Transpose(m2), world.Rank(), "Matrix Transpose Single");
}
///////////////////////////////////////////////
//Testing methdos with results in all ranks //
///////////////////////////////////////////////
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulAll(m1);//return the results in all ranks
mulAll.Mult(m2);
mulAll.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1 * m2, world.Rank(), "Matrix Multiplication All");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> addAll(m1square);
addAll.Addition(m2square);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> subAll(m1square);
subAll.Subtraction(m2square);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> transAll(m2);
transAll.Transpose();
addAll.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square + m2square, world.Rank(), "Matrix Addition All");
subAll.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square - m2square, world.Rank(), "Matrix Subtraction All");
transAll.GetResult(mResult);
MpiCompareTMatrixTest(mResult, TMatrixT<Double_t>(m2.GetNcols(), m2.GetNrows()).Transpose(m2), world.Rank(), "Matrix Transpose All");
//////////////////////////////////////////////////
//Testing methdos with multiple matrices types //
//////////////////////////////////////////////////
THilbertMatrixT<Double_t> him(side, side);
TMatrixTSparse<Double_t> sm1(rowm1, colm1);
TMatrixTSparse<Double_t> sm2(rowm2, colm2);
TMatrixTFlat<Double_t> fm1(m1);
TMatrixTFlat<Double_t> fm2(m2);
TMatrixTSparse<Double_t> smResult;
for (Int_t i = 0; i < rowm1; i++)
for (Int_t j = 0; j < colm1; j++) {
sm1[i][j] = i * j;
}
for (Int_t i = 0; i < rowm2; i++)
for (Int_t j = 0; j < colm2; j++) {
sm2[i][j] = i * j;
}
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulHim(m1square);//return the results in all ranks
mulHim.Mult(him);
mulHim.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square * TMatrixT<Double_t>(him), world.Rank(), "Matrix Multiplication HilbertMatrix");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulHim2(him);//return the results in all ranks
mulHim2.Mult(m1square);
mulHim2.GetResult(mResult);
MpiCompareTMatrixTest(mResult, TMatrixT<Double_t>(him)*m1square, world.Rank(), "Matrix Multiplication HilbertMatrix In Constructor");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulSm(m1);//return the results in all ranks
mulSm.Mult(sm2);
mulSm.GetResult(smResult);
MpiCompareTMatrixTest(smResult, m1 * sm2, world.Rank(), "Matrix Multiplication SparseMatrix");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulSm2(sm1);//return the results in all ranks
mulSm2.Mult(m2);
mulSm2.GetResult(smResult);
MpiCompareTMatrixTest(smResult, sm1 * m2, world.Rank(), "Matrix Multiplication SparseMatrix In Constructor");
//
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulFm(m1);//return the results in all ranks
mulFm.Mult(fm2);
mulFm.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1 * TMatrixT<Double_t>(fm2.GetMatrix()->GetNrows(), fm2.GetMatrix()->GetNcols(), fm2.GetMatrix()->GetMatrixArray()), world.Rank(), "Matrix Multiplication FlatMatrix");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulFm2(fm1);//return the results in all ranks
mulFm2.Mult(m2);
mulFm2.GetResult(mResult);
//NOTE fm matrix have data from m2, is the same tell m1*m2, just change the representation in memory
MpiCompareTMatrixTest(mResult, m1 * m2, world.Rank(), "Matrix Multiplication FlatMatrix In Constructor");
TVectorT<Double_t> vec(rowv);
for (Int_t i = 0; i < rowv; i++) vec[i] = i;
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulVec(m1);//return the results in all ranks
mulVec.Mult(vec);
mulVec.GetResult(mResult);
TMatrixT<Double_t> mr((m1 * vec).GetNrows(), 1, (m1 * vec).GetMatrixArray());
// mResult.Print();
// mr.Print();
MpiCompareTMatrixTest(mResult, mr, world.Rank(), "Matrix Multiplication with Vector");
return 0;
}
