JAVA collection problem

6 Message(s) by 4 Author(s) originally posted in java machine

From: toton

Date: Monday, July 24, 2006

Hi everyone,
I need to have alarge array

1. <programming> A collection of identically typed data items
	distinguished by their indices (or "subscripts").  The number
	of dimensions an array can have depends on the language but is
	usually unlimited.

	An array is a kind of {aggregate} data type.  A single
	ordinary variable (a "{scalar}") could be considered as a
	zero-dimensional array.  A one-dimensional array is also known
	as a "{vector}".

	A reference to an array element is written something like
	A[i,j,k] where A is the array name and i, j and k are the
	indices.  The {C} language is peculiar in that each index is
	written in separate brackets, e.g. A[i][j][k].  This expresses
	the fact that, in C, an N-dimensional array is actually a
	vector, each of whose elements is an N-1 dimensional array.

	Elements of an array are usually stored contiguously.
	Languages differ as to whether the leftmost or rightmost index
	varies most rapidly, i.e. whether each row is stored
	contiguously or each column (for a 2D array).

	Arrays are appropriate for storing data which must be accessed
	in an unpredictable order, in contrast to {lists} which are
	best when accessed sequentially.

	See also {associative array}.

	2. <architecture> A {processor array}, not to be confused with
	an {array processor}.

	(1995-01-25)

of small class

1. <programming> The prototype for an {object} in an
	{object-oriented language}; analogous to a {derived type} in a
	{procedural language}.  A class may also be considered to be a
	set of objects which share a common structure and behaviour.
	The structure of a class is determined by the {class
	variables} which represent the {state} of an object of that
	class and the behaviour is given by a set of {methods}
	associated with the class.

	Classes are related in a {class hierarchy}.  One class may be
	a specialisation (a "{subclass}") of another (one of its
	"{superclasses}") or it may be composed of other classes or it
	may use other classes in a {client-server} relationship.  A
	class may be an {abstract class} or a {concrete class}.

	See also {signature}.

	2. <programming> See {type class}.

	3. <networking> One of three types of {Internet addresses}
	distinguished by their most significant bits.

	3. <language> A language developed by the {Andrew Project}.
	It was one of the first attempts to add {object-oriented}
	features to {C}.

	(1995-05-01)

'es (in c# sense struct).
For premitive type

<theory, programming> (Or "data type") A set of values from
	which a {variable}, {constant}, {function}, or other
	{expression} may take its value.  A type is a classification
	of data that tells the {compiler} or {interpreter} how the
	programmer intends to use it.  For example, the process and
	result of adding two variables differs greatly according to
	whether they are integers, floating point numbers, or strings.

	Types supported by most programming languages include
	{integers} (usually limited to some range so they will fit in
	one {word} of storage), {Booleans}, {floating point numbers},
	and characters.  {Strings} are also common, and are
	represented as {lists} of characters in some languages.

	If s and t are types, then so is s -> t, the type of
	{functions} from s to t; that is, give them a term of type s,
	functions of type s -> t will return a term of type t.

	Some types are {primitive} - built-in to the language, with no
	visible internal structure - e.g. Boolean; others are
	composite - constructed from one or more other types (of
	either kind) - e.g. {lists}, {arrays}, {structures}, {unions}.
	{Object-oriented programming} extends this with {classes}
	which encapsulate both the structure of a type and the
	operations that can be performed on it.

	Some languages provide {strong typing}, others allow {implicit
	type conversion} and/or {explicit type conversion}.

	(2003-12-22)

s, as the ArrayList stores value types, hence it
is possible to use apache common primitives library

<programming, library> A collection of {subroutines} and
	{functions} stored in one or more files, usually in compiled
	form, for linking with other programs.  Libraries are one of
	the earliest forms of organised {code reuse}.  They are often
	supplied by the {operating system} or {software development
	environment} developer to be used in many different programs.
	The routines in a library may be general purpose or designed
	for some specific function such as three dimensional animated
	graphics.

	Libraries are linked with the user's program to form a
	complete {executable}.  The linking may be {static linking}
	or, in some systems, {dynamic linking}.

	(1998-11-21)

to save memory

<storage> These days, usually used synonymously with {Random
	Access Memory} or {Read-Only Memory}, but in the general sense
	it can be any device that can hold {data} in
	{machine-readable} format.

	(1996-05-25)

&
cache

<memory management> /kash/ A small fast memory holding
	recently accessed data, designed to speed up subsequent access
	to the same data.  Most often applied to processor-memory
	access but also used for a local copy of data accessible over
	a network etc.

	When data is read from, or written to, {main memory} a copy is
	also saved in the cache, along with the associated main memory
	address.  The cache monitors addresses of subsequent reads to
	see if the required data is already in the cache.  If it is (a
	{cache hit}) then it is returned immediately and the main
	memory read is aborted (or not started).  If the data is not
	cached (a {cache miss}) then it is fetched from main memory
	and also saved in the cache.

	The cache is built from faster memory chips than main memory
	so a cache hit takes much less time to complete than a normal
	memory access.  The cache may be located on the same
	{integrated circuit} as the {CPU}, in order to further reduce
	the access time.  In this case it is often known as {primary
	cache} since there may be a larger, slower {secondary cache}
	outside the CPU chip.

	The most important characteristic of a cache is its {hit rate}
	- the fraction of all memory accesses which are satisfied from
	the cache.  This in turn depends on the cache design but
	mostly on its size relative to the main memory.  The size is
	limited by the cost of fast memory chips.

	The hit rate also depends on the access pattern of the
	particular program being run (the sequence of addresses being
	read and written).  Caches rely on two properties of the
	access patterns of most programs: temporal locality - if
	something is accessed once, it is likely to be accessed again
	soon, and spatial locality - if one memory location is
	accessed then nearby memory locations are also likely to be
	accessed.  In order to exploit spatial locality, caches often
	operate on several words at a time, a "{cache line}" or "cache
	block".  Main memory reads and writes are whole {cache lines}.

	When the processor wants to write to main memory, the data is
	first written to the cache on the assumption that the
	processor will probably read it again soon.  Various different
	policies are used.  In a {write-through} cache, data is
	written to main memory at the same time as it is cached.  In a
	{write-back} cache it is only written to main memory when it
	is forced out of the cache.

	If all accesses were writes then, with a write-through policy,
	every write to the cache would necessitate a main memory
	write, thus slowing the system down to main memory speed.
	However, statistically, most accesses are reads and most of
	these will be satisfied from the cache.  Write-through is
	simpler than write-back because an entry that is to be
	replaced can just be overwritten in the cache as it will
	already have been copied to main memory whereas write-back
	requires the cache to initiate a main memory write of the
	flushed entry followed (for a processor read) by a main memory
	read.  However, write-back is more efficient because an entry
	may be written many times in the cache without a main memory
	access.

	When the cache is full and it is desired to cache another line
	of data then a cache entry is selected to be written back to
	main memory or "flushed".  The new line is then put in its
	place.  Which entry is chosen to be flushed is determined by a
	"{replacement algorithm}".

	Some processors have separate instruction and data caches.
	Both can be active at the same time, allowing an instruction
	fetch to overlap with a data read or write.  This separation
	also avoids the possibility of bad {cache conflict} between
	say the instructions in a loop and some data in an array which
	is accessed by that loop.

	See also {direct mapped cache}, {fully associative cache},
	{sector mapping}, {set associative cache}.

	(1997-06-25)

overflow.
However, for array of classes, which are small enough, I want to
store them as value, so that they occupy contiguous memory space

<character> The space character, {ASCII} 32.

	See {octal forty}.

,
rether than heving them reference

1. <programming> An {address}, from the point of view of a
	programming language.  A pointer may be typed, with its {type}
	indicating the type of data to which it points.

	The terms "pointer" and "reference" are generally
	interchangable although particular programming languages often
	differentiate these two in subtle ways.  For example, {Perl}
	always calls them references, never pointers.  Conversely, in
	C, "pointer" is used, although "a reference" is often used to
	denote the concept that a pointer implements.

	{Anthony Hoare} once said:

	Pointers are like jumps, leading wildly from one part of the
	data structure to another.  Their introduction into high-level
	languages has been a step backward from which we may never
	recover.

	[C.A.R.Hoare "Hints on Programming Language Design", 1973,
	Prentice-Hall collection of essays and papers by Tony Hoare].

	2. <operating system> (Or "mouse pointer") An {icon}, usually
	a small arrow, that moves on the screen in response to
	movement of a {pointing device}, typically a {mouse}.  The
	pointer shows the user which object on the screen will be
	selected etc. when a mouse button is clicked.

	(1999-07-07)

d from list.
This is just to decrease cache overflow error

1. A discrepancy between a computed, observed, or measured
	value or condition and the true, specified, or theoretically
	correct value or condition.

	2. <programming> A mental mistake made by a programmer that
	may result in a program {fault}.

	3. (verb) What a program does when it stops as result of a
	programming error.

	(2000-03-28)

& speedup things. Is
there a possible way to do it?.
In general, is there a possible way to locate the class in local stack

<programming> (See below for synonyms) A data structure for
	storing items which are to be accessed in last-in first-out
	order.

	The operations on a stack are to create a new stack, to "push"
	a new item onto the top of a stack and to "pop" the top item
	off.  Error conditions are raised by attempts to pop an empty
	stack or to push an item onto a stack which has no room for
	further items (because of its implementation).

	Most processors include support for stacks in their
	{instruction set architectures}.  Perhaps the most common use
	of stacks is to store {subroutine} arguments and return
	addresses.  This is usually supported at the {machine code}
	level either directly by "jump to subroutine" and "return from
	subroutine" instructions or by {auto-increment} and
	auto-decrement {addressing modes}, or both.  These allow a
	contiguous area of memory to be set aside for use as a stack
	and use either a special-purpose {register} or a general
	purpose register, chosen by the user, as a {stack pointer}.

	The use of a stack allows subroutines to be {recursive} since
	each call can have its own calling context, represented by a
	stack frame or {activation record}.  There are many other
	uses.  The programming language {Forth} uses a data stack in
	place of variables when possible.

	Although a stack may be considered an {object} by users,
	implementations of the object and its access details differ.
	For example, a stack may be either ascending (top of stack is
	at highest address) or descending.  It may also be "full" (the
	stack pointer points at the top of stack) or "empty" (the
	stack pointer points just past the top of stack, where the
	next element would be pushed).  The full/empty terminology is
	used in the {Acorn Risc Machine} and possibly elsewhere.

	In a list-based or {functional language}, a stack might be
	implemented as a {linked list} where a new stack is an empty
	list, push adds a new element to the head of the list and pop
	splits the list into its head (the popped element) and tail
	(the stack in its modified form).

	At {MIT}, {pdl} used to be a more common synonym for stack,
	and this may still be true.  {Knuth} ("The Art of Computer
	Programming", second edition, vol. 1, p. 236) says:

	  Many people who realised the importance of stacks and queues
	  independently have given other names to these structures:
	  stacks have been called push-down lists, reversion storages,
	  cellars, dumps, nesting stores, piles, last-in first-out
	  ("LIFO") lists, and even yo-yo lists!

	[{Jargon File}]

	(1995-04-10)

,
rather than heap

1. <programming> An area of memory used for {dynamic memory
	allocation} where blocks of memory are allocated and freed in
	an arbitrary order and the pattern of allocation and size of
	blocks is not known until {run time}.  Typically, a program
	has one heap which it may use for several different purposes.

	Heap is required by languages in which functions can return
	arbitrary data structures or functions with {free variables}
	(see {closure}).  In {C} functions {malloc} and {free} provide
	access to the heap.

	Contrast {stack}.  See also {dangling pointer}.

	2. <programming> A data structure with its elements partially
	ordered (sorted) such that finding either the minimum or the
	maximum (but not both) of the elements is computationally
	inexpensive (independent of the number of elements), while
	both adding a new item and finding each subsequent
	smallest/largest element can be done in O(log n) time, where n
	is the number of elements.

	Formally, a heap is a {binary tree} with a key in each {node},
	such that all the {leaves} of the tree are on two adjacent
	levels; all leaves on the lowest level occur to the left and
	all levels, except possibly the lowest, are filled; and the
	key in the {root} is at least as large as the keys in its
	children (if any), and the left and right subtrees (if they
	exist) are again heaps.

	Note that the last condition assumes that the goal is finding
	the minimum quickly.

	Heaps are often implemented as one-dimensional {arrays}.
	Still assuming that the goal is finding the minimum quickly
	the {invariant} is

	   heap[i] <= heap[2*i] and heap[i] <= heap[2*i+1] for all i,

	where heap[i] denotes the i-th element, heap[1] being the
	first.  Heaps can be used to implement {priority queues} or in
	{sort} algorithms.

	(1996-02-26)

or free store? Some common base

<mathematics> {radix}.

class or weak
reference type? abir

From: Andrew Reilly

Date: Monday, July 24, 2006

wrote in message:

1. <unit, text> (Sometimes abbreviated "pt") The unit of
	length used in {typography} to specify text character height,
	{rule} width, and other small measurements.

	There are six slightly different definitions: {Truchet point},
	{Didot point}, {ATA point}, {TeX point}, {Postscript point},
	and {IN point}.

	In Europe, the most commonly used is Didot and in the US, the
	formerly standard ATA point has essentially been replaced by
	the PostScript point due to the demise of traditional
	typesetting systems and rise of desktop computer based systems
	running software such as {QuarkXPress}, {Adobe InDesign} and
	{Adobe Pagemaker}.

	There are 20 {twips} in a point and 12 points in a {pica}
	(known as a "Cicero" in the Didot system).

	{Different point systems
	(http://www.vakcer.com/oberon/dtp/fonts/point.htm)}.

	(2004-12-23)

	2. <hardware> To move a {pointing device} so that the
	on-screen pointer is positioned over a certain object on the
	screen such as a {button} in a {graphical user interface}.  In
	most {window systems} it is then necessary to {click} a
	(physical) button on the pointing device to activate or select
	the object.  In some systems, just pointing to an object is
	known as "mouse-over" {event} which may cause some help text
	(called a "tool tip" in {Windows}) to be displayed.

	(2001-05-21)

ers is pretty cheap.

That depends a *lot* on the type of object, IMO. Consider things like
complex numbers

(Scientific computation) Output from a computation that may
	not be significant but at least indicates that the program is
	running.  Numbers may be used to placate management, grant
	sponsors, etc.  "Making numbers" means running a program
	because output - any output, not necessarily meaningful output
	- is needed as a demonstration of progress.

	See {pretty pictures}, {math-out}, {social science number}.

	[{Jargon File}]

	(1995-01-13)

, or (dunno, I've less experience with these:) (x,y,z)
coordinate tuples. Compared to cache-prefetch-assisted in-order access
that you get from an embedded array, pointer dereferences are way
expensive.

if you *really* want to do something like this, you can allocate an
int[] and logically partition

1. <storage> A {logical} section of a {disk}.  Each partition
	normally has its own {file system}.  {Unix} tends to treat
	partitions as though they were separate physical entities.

	2. <mathematics> A division of a set into subsets so that each
	of its elements is in exactly one subset.

	(1996-12-09)

it in the code

<software> Instructions for a computer in some programming
	language, often {machine language}.  The word "code" is often
	used to distinguish instructions from {data} (e.g. "The code
	is marked 'read-only'") whereas "{software}" is used in
	contrast with "{hardware}" and may consist of more than just
	code.

	(2000-04-08)

yourself, but this is VERY
nasty, break

1. To cause to be {broken} (in any sense).  "Your latest patch
	to the editor broke the paragraph commands."

	2. (Of a program) To stop temporarily, so that it may
	debugged.  The place where it stops is a "{breakpoint}".

	3. To send an {EIA-232} break (two character widths of line
	high) over a {serial line}.

	4. [Unix] To strike whatever key currently causes the tty
	driver to send SIGINT to the current process.  Normally,
	break, delete or {control-C} does this.

	5. "break break" may be said to interrupt a conversation (this
	is an example of verb doubling).  This usage comes from radio
	communications, which in turn probably came from landline
	telegraph/teleprinter usage, as badly abused in the Citizen's
	Band craze a few years ago.

	6. {pipeline break}.

	7. {break statement}.

	[{Jargon File}]

	(2004-03-24)

s the OO philosophy, etc.

Sometimes you just have to break it. I'm pretty sure that a good matrix
arithmetic class'd manage complex numbers the way Matlab does: not as
objects of type "complex", but as a complex-vector

1. <mathematics> A member of a {vector space}.

	2. <graphics> A line or movement defined by its end points, or
	by the current position and one other point.  See {vector
	graphics}.

	3. <operating system> A memory location containing the address
	of some code, often some kind of {exception} handler or other
	{operating system} service.  By changing the vector to point
	to a different piece of code it is possible to modify the
	behaviour of the operating system.

	Compare {hook}.

	4. <programming> A one-dimensional {array}.

	(1996-09-30)

class that contains a
vector of floats (or doubles), and another possibly-null vector for the
imaginary part. You still get your OO paradigm, but only at scales larger
than vector. Scalars have to be done differently.

at least from the language
1. <language, programming> {programming language}.

	2. <human language> {natural language}.

	(1998-09-07)
perspective, all JAVA objects are
heap-allocated and accessed through a direct reference (pointer).

Eiffel

<language> An {object-oriented} language produced by {Bertrand
	Meyer} in 1985.  Eiffel has {classes} with {multiple
	inheritance} and {repeated inheritance}, {deferred class}es
	(like {Smalltalk}'s {abstract class}), and {clusters} of
	classes.  Objects can have both {static types} and {dynamic
	types}.  The dynamic type must be a descendant of the static
	(declared) type.  {Dynamic binding} resolves {multiple
	inheritance} clashes.  It has flattened forms of classes, in
	which all of the inherited features are added at the same
	level and {generic class}es parametrised by type.

	Other features are {persistent objects}, {garbage collection},
	{exception} handling, {foreign language interface}.  Classes
	may be equipped with {assertions} (routine preconditions and
	postconditions, class {invariants}) implementing the theory of
	"{Design by Contract}" and helping produce more reliable
	software.

	Eiffel is compiled to {C}.  It comes with libraries containing
	several hundred classes: data structures and {algorithms}
	(EiffelBase), graphics and user interfaces (EiffelVision) and
	language analysis (EiffelLex, EiffelParse).

	The first release of Eiffel was release 1.4, introduced at the
	first {OOPSLA} in October 1986.  The language proper was first
	described in a University of California, Santa Barbara report
	dated September 1985.

	Eiffel is available, with different libraries, from several
	sources including {Interactive Software Engineering}, USA (ISE
	Eiffel version 3.3); Sig Computer GmbH, Germany (Eiffel/S);
	and {Tower, Inc.}, Austin (Tower Eiffel).

	The language definition is administered by an open
	organisation, the Nonprofit International Consortium for
	Eiffel (NICE).  There is a standard kernel library.

	An {Eiffel source checker} and compiler {front-end} is
	available.

	Latest version: 4.2, as of 1998-10-28.

	Latest version: ISE Eiffel version 3.3.

	See also {Sather}, {Distributed Eiffel}, {Lace}, {shelf}.

	E-mail: <queries@eiffel.com>.

	["Eiffel: The Language", Bertrand Meyer, P-H 1992].

	(1998-11-15)

(which pre-dates JAVA) has a nice way of handling this. It has
explicit syntax/key words for managing unboxed objects, in arrays, or as
class members. I imagine that it makes the compiler

<programming, tool> A program that converts another program
	from some {source language} (or {programming language}) to
	{machine language} (object code).  Some compilers output
	{assembly language} which is then converted to {machine
	language} by a separate {assembler}.

	A compiler is distinguished from an assembler by the fact that
	each input statement does not, in general, correspond to a
	single machine instruction or fixed sequence of instructions.
	A compiler may support such features as automatic allocation
	of variables, arbitrary arithmetic expressions, control
	structures such as FOR and WHILE loops, variable {scope},
	input/ouput operations, {higher-order functions} and
	{portability} of source code.

	{AUTOCODER}, written in 1952, was possibly the first primitive
	compiler.  {Laning and Zierler}'s compiler, written in
	1953-1954, was possibly the first true working algebraic
	compiler.

	See also {byte-code compiler}, {native compiler}, {optimising
	compiler}.

	(1994-11-07)

more complicated, but
it does let you keep your paradigm "all the way down" with good efficiency.

(Hmm: there are JAVA-bytecode back-ends for at least two Eiffel compilers
that I know about, but I have not used them. I wonder how they manage to
support this Eiffel language feature

<jargon> 1. A good property or behaviour (as of a program).
	Whether it was intended or not is immaterial.

	2. An intended property or behaviour (as of a program).
	Whether it is good or not is immaterial (but if bad, it is
	also a {misfeature}).

	3. A surprising property or behaviour; in particular, one that
	is purposely inconsistent because it works better that way -
	such an inconsistency is therefore a {feature} and not a
	{bug}.  This kind of feature is sometimes called a {miswart}.

	4. A property or behaviour that is gratuitous or unnecessary,
	though perhaps also impressive or cute.  For example, one
	feature of {Common LISP}'s "format" function is the ability to
	print numbers in two different Roman-numeral formats (see
	{bells, whistles, and gongs}).

	5. A property or behaviour that was put in to help someone
	else but that happens to be in your way.

	6. A bug that has been documented.  To call something a
	feature sometimes means the author of the program did not
	consider the particular case, and that the program responded
	in a way that was unexpected but not strictly incorrect.  A
	standard joke is that a bug can be turned into a {feature}
	simply by documenting it (then theoretically no one can
	complain about it because it's in the manual), or even by
	simply declaring it to be good.  "That's not a bug, that's a
	feature!" is a common catch-phrase.  Apparently there is a
	Volkswagen Beetle in San Francisco whose license plate reads
	"FEATURE".

	See also {feetch feetch}, {creeping featurism}, {wart}, {green
	lightning}.

	The relationship among bugs, features, misfeatures, warts and
	miswarts might be clarified by the following hypothetical
	exchange between two hackers on an airliner:

	A: "This seat doesn't recline."

	B: "That's not a bug, that's a feature.  There is an emergency
	exit door built around the window behind you, and the route
	has to be kept clear."

	A: "Oh.  Then it's a misfeature; they should have increased
	the spacing between rows here."

	B: "Yes.  But if they'd increased spacing in only one section
	it would have been a wart - they would've had to make
	nonstandard-length ceiling panels to fit over the displaced
	seats."

	A: "A miswart, actually.  If they increased spacing throughout
	they'd lose several rows and a chunk out of the profit margin.
	So unequal spacing would actually be the Right Thing."

	B: "Indeed."

	"Undocumented feature" is a common euphemism for a {bug}.

	7. An attribute or function of a {class} in {Eiffel}.

	[{Jargon File}]

	(1995-10-22)

*and* be JVM-compatible?)

Cheers,

--
Andrew

From: toton

Date: Tuesday, July 25, 2006

wrote in message:
wrote in message:
> basically, no. and you're probably not going to get as much speed-up
> or space savings as you might think. even if not allocated
> contiguously, the copying garbage collector is likely to organize them
> to be contiguous after the first GC. the extra indirect from the
> array of pointers is pretty cheap.
That depends a *lot* on the type of object, IMO. Consider things like
complex numbers, or (dunno, I've less experience with these:) (x,y,z)
coordinate tuples. Compared to cache-prefetch-assisted in-order access
that you get from an embedded array, pointer dereferences are way
expensive.

The problem is, the objects are small, but plenty in number. u can
think them as 2D points ... and I've a fixed size array for them...
Now I access them sequentially, but may not create them sequentally.
Thus if I dont have all the points in nearby place in memory it not
only causes one extra indirection, but also cache overflow. The cost
comes high for computational geomery....
I event

1. <software> An occurrence or happening of significance to a
	task or program, such as the completion of an asynchronous
	input/output operation.  A task may wait for an event or any
	of a set of events or it may (request to) receive asynchronous
	notification (a {signal} or {interrupt}) that the event has
	occurred.

	See also {event-driven}.

	2. <data> A transaction or other activity that affects the
	records in a file.

	(2000-02-09)

dont want the objects to be garbage collected. When I create a
new point, I want to put it it the array at the appropriate place (The
array behaves like a circular buffer

1. An area of memory used for storing messages.  Typically, a
	buffer will have other attributes such as an input pointer
	(where new data will be written into the buffer), and output
	pointer (where the next item will be read from) and/or a count
	of the space used or free.  Buffers are used to decouple
	processes so that the reader and writer may operate at
	different speeds or on different sized blocks of data.

	There are many different algorithms for using buffers, e.g.
	first-in first-out (FIFO or shelf), last-in first-out (LIFO or
	stack), double buffering (allowing one buffer to be read while
	the other is being written), cyclic buffer (reading or writing
	past the end wraps around to the beginning).

	2. An electronic device to provide compatibility between two
	signals, e.g. changing voltage levels or current capability.

here). Thus, no memory management
is at all needed for these large number of objects in practical sense.
(Want to do something like C++

<language> One of the most used {object-oriented} languages, a
	superset of {C} developed primarily by {Bjarne Stroustrup}
	<bs@alice.att.com> at {AT&T} {Bell Laboratories} in 1986.

	In C++ a {class} is a user-defined {type}, syntactically a
	{struct} with {member functions}.  {Constructors} and
	{destructors} are member functions called to create or destroy
	{instances}.  A {friend} is a nonmember function that is
	allowed to access the private portion of a class.  C++ allows
	{implicit type conversion}, {function inlining}, {overloading}
	of operators and function names, and {default function
	arguments}.  It has {streams} for I/O and {references}.

	C++ 2.0 (May 1989) introduced {multiple inheritance},
	{type-safe linkage}, pointers to members, and {abstract
	classes}.

	C++ 2.1 was introduced in ["Annotated C++ Reference Manual",
	B. Stroustrup et al, A-W 1990].

	{MS-DOS
	(ftp://grape.ecs.clarkson.edu/pub/msdos/djgpp/djgpp.zip)},
	{Unix ANSI C++
	(ftp://gnu.org/pub/gnu/g++-1.39.0.tar.Z)} - X3J16
	committee. (They're workin' on it).

	See also {cfront}, {LEDA}, {uC++}.

	{Usenet} newsgroup: {news:comp.lang.c++}.

	["The C++ Programming Language", Bjarne Stroustrup, A-W,
	1986].

	(1996-06-06)

placement new, which is used inside STl
vector class). Thus garbage collector will also get a relief rather
than managing large no of objects to e garbage collected....
Well, when a new Point comes, I really create a new point to put it
into a circular buffer,
rether than reintializing the field

<data, database> An area of a {database} {record}, or
	{graphical user interface} {form}, into which a particular
	item of data is entered.

	Example usage: "The telephone number field is not really a
	numerical field", "Why do we need a four-digit field for the
	year?".

	A {database} {column} is the set of all instances of a given
	field from all records in a {table}.

	(1999-04-26)

of the old point, which was already
there to a new value.
This is done, to keep in mind, I do computation on them in seperate
thread

1. See {multithreading}.

	2. See {threaded code}.

	3. {topic thread}.

	[{Jargon File}]

. Once I create a point, it is immutable, fields can not be
changed. Thus thread synchronization problems aren't there (which is
another costly thing to do).
Now the points come, the circular buffer stores them, discards the
old, and process

1. <operating system, software> The sequence of states of an
	executing {program}.  A process consists of the program {code}
	(which may be shared with other processes which are executing
	the same program), private data, and the state of the
	{processor}, particularly the values in its {registers}.  It
	may have other associated resources such as a {process
	identifier}, open files, {CPU time} limits, {shared memory},
	{child processes}, and {signal handlers}.

	One process may, on some {platforms}, consist of many
	{threads}.  A {multitasking} {operating system} can run
	multiple processes {concurrently} or in {parallel}, and allows
	a process to spawn "child" processes.

	(2001-06-16)

	2. <business> The sequence of activities, people, and systems
	involved in carrying out some business or achieving some
	desired result.  E.g. software development process, project
	management process, configuration management process.

	(2001-06-16)

in different thread.
Thus, it is better to have them in neaarby memory place, and not t get
garbage collected.
To me, it looks very much like C++ by value array, or C# struct.
The general method

<programming> The name given in {Smalltalk} and other
	{object-oriented languages} to a procedure or routine
	associated with one or more {classes}.  An {object} of a
	certain class knows how to perform actions, e.g. printing
	itself or creating a new instance of itself, rather than the
	function (e.g. printing) knowing how to handle different types
	of object.

	Different classes may define methods with the same name
	(i.e. methods may be {polymorphic}).  The term "method" is used
	both for a named operation, e.g. "PRINT" and also for the code
	which a specific class provides to perform tha
	t operation.

	Most methods operate on objects that are instances of a
	certain class.  Some object-oriented languages call these
	"object methods" to distinguish then from "{class methods}".

	In {Smalltalk}, a method is defined by giving its name,
	documentation, temporary local variables and a sequence of
	expressions separated by "."s.

	(2000-03-22)

do work, but time goes high, ( I think JAVA do
outperform C++ even when it comes for looped processing... or hot
spots, and it has reason to do so). But this is a particular case
where I feel, stack allocation is better, and garbage collector should
not perform...
I've heard that mustang ( JAVA1.6) performs escape analysis to
allocate small objects in stack rether than heap, to speed up this kind
of feature... Do anyone know how it performs?

abir

> if you *really* want to do something like this, you can allocate an
> int[] and logically partition it in the code yourself, but this is VERY
> nasty, breaks the OO philosophy, etc.
Sometimes you just have to break it. I'm pretty sure that a good matrix
arithmetic class'd manage complex numbers the way Matlab does: not as
objects of type "complex", but as a complex-vector class that contains a
vector of floats (or doubles), and another possibly-null vector for the
imaginary part. You still get your OO paradigm, but only at scales larger
than vector. Scalars have to be done differently.
> at least from the language perspective, all JAVA objects are
> heap-allocated and accessed through a direct reference (pointer).
Eiffel (which pre-dates JAVA) has a nice way of handling this. It has
explicit syntax/key words for managing unboxed objects, in arrays, or as
class members. I imagine that it makes the compiler more complicated, but
it does let you keep your paradigm "all the way down" with good efficiency.
(Hmm: there are JAVA-bytecode back-ends for at least two Eiffel compilers
that I know about, but I have not used them. I wonder how they manage to
support this Eiffel language feature *and* be JVM-compatible?)
Cheers,
--
Andrew

From: peter d

Date: Tuesday, July 25, 2006

As toton put it so eloquently,

I need to have alarge array of small class'es (in c# sense struct).

i think you mean objects.

However, for array of classes, which are small enough, I want to
store them as value, so that they occupy contiguous memory space,
rether than heving them referenced from list.
This is just to decrease cache overflow error & speedup things. Is
there a possible way to do it?.

basically, no. and you're probably not going to get as much speed-up
or space savings as you might think. even if not allocated
contiguously, the copying garbage collector is likely to organize them
to be contiguous after the first GC. the extra indirect from the
array of pointers is pretty cheap.

if you *really* want to do something like this, you can allocate an
int[] and logically partition it in the code yourself, but this is
VERY nasty, breaks the OO philosophy, etc.

In general, is there a possible way to locate the class in local stack,
rather than heap or free store? Some common base class or weak
reference type?

same deal. the best to could do is create a couple variables with the
"fields" and manually inline

<programming> (Or "unfold") To replace a {function} call with
	an instance of the function's body.  {Actual argument}
	expressions are substituted for {formal parameters} as in
	{beta reduction}.  Inlining is usually done as a
	{compile-time} transformation.

	If done recklessly (e.g. attempting to inline a {recursive}
	function) the {compiler} will fail to terminate.  If done
	over-enthusiastically the code size may increase
	exponentially, e.g. if function f calls g twice, and g calls h
	twice and h is inlined in g which is inlined in f (in either
	order) then there will be four copies of h's body in f.

	See also {linear argument}, {unfold/fold}.

	(1994-11-03)

the code in the method.

at least from the language perspective, all JAVA objects are
heap-allocated and accessed through a direct reference (pointer). I presume a virtual

<jargon, architecture> (Via the technical term {virtual
	memory}, probably from the term "virtual image" in optics)
	1. Common alternative to {logical}; often used to refer to the
	artificial objects (like addressable {virtual memory} larger
	than physical memory) created by a computer system to help the
	system control access to shared resources.

	2. Simulated; performing the functions of something that isn't
	really there.  An imaginative child's doll may be a virtual
	playmate.

	Opposite of {real} or physical.

	[{Jargon File}]

	(1994-11-30)

machine'd be allowed to break these rules in
cases it can prove equivalence, but I doubt this is used much if at
all. I believe VM implementers instead focus on making the memory
manager fast, fast, and fast.

--
Peter Dillinger
http://www.peterd.org

From: Chris Uppal

Date: Tuesday, July 25, 2006

wrote in message:

The problem is, the objects are small, but plenty in number. u can
think them as 2D points ... and I've a fixed size array for them...

I think that, if the performance you are seeing is /actually/ inadequate (which
I find quite plausible, but you have not posted anything quantative so I can not
tell), then you will be forced to give up on OO style programming

1. The art of debugging a blank sheet of paper (or, in these
	days of on-line editing, the art of debugging an empty file).

	2. A pastime similar to banging one's head against a wall, but
	with fewer opportunities for reward.

	3. The most fun you can have with your clothes on (although
	clothes are not mandatory).

	[{Jargon File}]

	(2003-02-12)

for this.

If you want to represent a circular buffer of 2D points, then you could use a
single double[] array with the x and y co-ordinates at even and odd indexes.
Alternatively (and perhaps more feasibly if the data

<data, data processing, jargon> /day't*/ (Or "raw data")
	Numbers, {characters}, {images}, or other method of recording,
	in a form which can be assessed by a human or (especially)
	input into a {computer}, stored and {processed} there, or
	transmitted on some {digital channel}.  Computers nearly
	always represent data in {binary}.

	Data on its own has no meaning, only when interpreted by some
	kind of {data processing system} does it take on meaning and
	become {information}.

	People or computers can find patterns in data to perceive
	information, and information can be used to enhance
	{knowledge}.  Since knowledge is prerequisite to wisdom, we
	always want more data and information.  But, as modern
	societies verge on {information overload}, we especially need
	better ways to find patterns.

	1234567.89 is data.

	"Your bank balance has jumped 8087% to $1234567.89" is
	information.

	"Nobody owes me that much money" is knowledge.

	"I'd better talk to the bank before I spend it, because of
	what has happened to other people" is wisdom.

	(1999-04-30)

is more complicated than
just a pair of numbers), you could use a bunch of arrays: one for each "field".

You can give that a more OO flavour

<jargon> (US: flavor) 1. Variety, type, kind.  "DDT commands
	come in two flavors."  "These lights come in two flavors, big
	red ones and small green ones."  See {vanilla}.

	2. The attribute that causes something to be {flavourful}.
	Usually used in the phrase "yields additional flavour".  "This
	convention yields additional flavor by allowing one to print
	text either right-side-up or upside-down."  See {vanilla}.

	This usage was certainly reinforced by the terminology of
	quantum chromodynamics, in which quarks (the constituents of,
	e.g. protons) come in six flavors (up, down, strange, charm,
	top, bottom) and three colours (red, blue, green), however,
	hackish use of "flavor" at {MIT} predated QCD.

	3. The term for "{class}" (in the {object-oriented} sense) in
	the {LISP Machine} {Flavors} system.  Though the Flavors
	design has been superseded (notably by the {Common LISP}
	{CLOS} facility), the term "flavor" is still used as a general
	synonym for "class" by some {Lisp} hackers.

	(1994-11-01)

by creating objects which simply contain an
index into the array(s), and which implement their "fields" by accessing the
arrays. Needless to say, the more performance-critical parts of the code'd
not use those objects, but other parts of the code (presumably the bulk of it,
even if it is boring) could use them.

Other that that (which basically amounts to writting C in JAVA), I do not think
you've any option

<software> (Or "option", "flag", "switch", "option switch") An
	argument to a command that modifies its function rather than
	providing data.  Options generally start with "-" in {Unix} or
	"/" in {MS-DOS}.  This is usually followed by a single letter
	or occasionally a digit.

	Some commands require each option to be a separate argument,
	introduced by a new "-" or "/", others allow multiple option
	letters to be concatenated into a single argument with a
	single "-" or "/", e.g. "ls -al".  A few Unix commands
	(e.g. {ar}, {tar}) allow the "-" to be omitted.  Some options
	may or must be followed by a value, e.g. "cc prog.c -o prog",
	sometimes with and sometimes without an intervening space.

	{getopt} and {getopts} are commands for parsing command line
	options.  There is also a {C} library routine called getopt
	for the same purpose.

	(1996-12-11)

but to switch

1. <programming> {switch statement}.

	2. <software> {command line option}.

	3. <networking> {packet switch}, {circuit switch}.

	(1999-01-14)

to a different language.

-- chris

From: peter d

Date: Tuesday, July 25, 2006

As Chris Uppal put it so eloquently,

Other that that (which basically amounts to writting C in JAVA), I do not think
you've any option but to switch to a different language.

as in JNI

--
Peter Dillinger
http://www.peterd.org

Next Message: Alternative to JVM

Blogs related to JAVA collection problem

Mapping collections (updated)
SOAP supports this natively. The problem with this mechanism however arises from the fact that collections in java are untyped. Thus, to support collections on Java 1.4, a little bit of extra work is required. ...

Why to Use Generics in JAVA
How many times have you faced a Java.lang.ClassCastException while handling Collections? Even if you are a good programmer then also you must have faced this problem sometimes or the other, and if you are not then of course many a times ...

Garbage collection DO exists in C#
Like Java it is able to remove objects that is not in use anymore without being ... This new garbage collection is a property named Tag in the Control class. ... The problem is that changing the model (Tag property) does not have any ...

Blogger's Block #4: Ruby and Java and Stuff
Java's collections library is decent, but not superb. It's nice having the data ... Anyway, Java's biggest failing, I've decided, is its lack of syntax for literal data objects. ... Don't ever let 'em tell you it doesn't cause problems. ...

Dspace Community-list; adding most popular collections entries hack
This way, you could then do a descending sort on the count to get the items with the most number of accesses — ie, probably your most used collections. The initial problem that I ran into was I wanted to use Java’s HashMap like a PHP ...

How We Solved our Garbage Collection Pausing Problem
Needless to say this was a huge performance problem. Pauses are caused by major garbage collections. Minor garbage collections do not cause pausing. ... java ... -XX:+DisableExplicitGC -XX:+UseConcMarkSweepGC -XX:NewSize=1200m ...