Where results make sense

About us   |   Why use us?   |   Reviews   |   PR   |   Contact us

Ads by Google

Related Topics

DragonFly BSD

Serializing tokens - Wikipedia, the free encyclopedia In computer science, serializing tokens are a concept in concurrency control arising from the ongoing development of DragonFly BSD. Serializing tokens allow programmers to write multiprocessor-safe code without themselves or the lower level subsystems needing to be aware of every single entity that may also be holding the same token. Tokens are similar to mutexes in that they can, if used correctly, prevent multiple threads from accessing a shared resource at the same time. en.wikipedia.org /wiki/Serializing_tokens   (831 words)

DragonFly BSD - Wikipedia, the free encyclopedia Atomic operations, spinlocks, critical sections, mutexes, serializing tokens and message queues are all possible methods that can be used to prevent concurrent access. Serializing tokens are used to prevent concurrent accesses from other CPUs and may be held simultaneously by multiple threads, ensuring that only one of those threads is running at any given time. Among other things, the use of serializing tokens prevents many of the situations that could result in deadlocks and priority inversions when using mutexes, as well as greatly simplifying the design and implementation of a many-step procedure that would require a resource to be shared among multiple threads. en.wikipedia.org /wiki/DragonFly_BSD   (2898 words)

Token manager for execution of global operations utilizing multiple tokens - Patent 6460101 Serialization of global operations within a multi-processor system is achieved utilizing a plurality of tokens each permitting completion of a single global operation, requiring a bus master to acquire the token for completion of each individual global operation initiated by that bus master. The token manager allows only n bus masters to own a token at a time (where n is the number of token supported), and infers release of a token from a combined response acknowledging a combined request or an operation request containing the token number assigned to a global operation. Serialization of global operations within a multiprocessor system is achieved utilizing a plurality of tokens each permitting completion of a single global operation, requiring a bus master to acquire the token for completion of each individual global operation initiated by that bus master. www.freepatentsonline.com /6460101.html   (7804 words)

Re: [Serial] I18N WG last call comments from Jonathan Robie on 2004-10-26 (public-qt-comments@w3.org from October 2004) Serializing a sequence of atomic values is not the same thing as "concatenating strings". The default for serializing a sequence of tokens defined by XML Schema pretty much has to be the format defined by XML Schema, or else XML processors won't be able to read serialized documents. Linguistic tokens and delimiters are not the same as computerlanguage tokens and delimiters. lists.w3.org /Archives/Public/public-qt-comments/2004Oct/0064.html   (504 words)

VIAS Encyclopedia: Locking A lock token is a type of state token, represented as a URI, which identifies a particular lock. A lock token is returned by every successful LOCK operation in the lockdiscovery property in the response body, and can also be found through lock discovery on a resource. If another principal locks a resource that a principal wishes to access, it is useful for the second principal to be able to find out who the first principal is. For this purpose the lockdiscovery property is provided. www.vias.org /encyclopedia/rfc2518_005.html   (1882 words)

Re: [xml-dev] Create XML In fact, for me, one of the most common problems of using using tokens in data content is that I invariably forget to normalize-space() the data first. Tokens are useful, and they are a major use of attributes. Programmers who don't delimit data being serialized into text (or, as Dare points out, use APIs to take care of this) have only themselves to blame: it is the nature of representing text-in-text that it needs delimiting (or escaping, or references, or formatting-conventions). www.oxygenxml.com /archives/xml-dev/200306/msg00691.html   (322 words)

[No title]   (Site not responding. Last check: 2007-11-01) The form token unit generates, for each processed instruction in the thread body, a result token destined to the next instruction in the sequential thread; this result token is directly passed to the matching unit in the following cycle. In this case, all instructions in the thread body are ready for execution as soon as all tokens on inbound arcs have been synchronized and the values passed on them have been made available to the instructions in the thread body. Then, all instructions in the thread body are ready for execution as soon as a precalculated number of tokens have been synchronized and the values in the frame have been made available to the instructions in the thread body. www.ubka.uni-karlsruhe.de /vvv/1998/informatik/30/30.text   (4881 words)

[Twisted-commits] r10825 - more docs This tells Banana that serialization needs +to wait for a while (perhaps we are streaming data from another source which +has run dry, or we are trying to implement some kind of rate limiting). Knowing which method of your FooObject failed -during serialization isn't very useful when you have 500 of them inside your -data structure and you need to know whether it was bar.thisfoo -or bar.thatfoo which caused the problem. This is where we break cycles in the +object graph: before serializing the object, we record a reference to it +(the openID), and any time we encounter the object again, we send the +reference number instead of a new copy. twistedmatrix.com /pipermail/twisted-commits/2004-May/011323.html   (4311 words)

Token entry, token bus, token ring hubs Token entry Token entry Serializing tokens are used to prevent concurrent accesses from other CPUs. Token entry Token entry The serializing token code is evolving into something quite similar to the. Each token is a pair containing the decorations for that token and the characters that. www.lookpictures.info /token/token_entry.html   (947 words)

Chris Keyser's WebLog Serialization I've described in previous blogs and that remains the same process as when serializing the token for persistence to a database. Typically the token id should only need to be consistent within a particular message, while the SCT identifier is consistent across all messages. There are two tokens we need to be concerned with - the first is the SCT itself, and the second is the "base token" of the SCT. blogs.msdn.com /chriskeyser   (4407 words)

DragonFly - Light Weight Kernel Threading Model A serializing token may be held by any number of threads simultaneously. A thread may hold serializing tokens through a thread yield or blocking condition, but must understand that another thread holding those tokens may be allowed to run while the first thread is not running (blocked or yielded away). Serializing tokens may also be used to protect threads from preempting interrupts that attempt to obtain the same token. www.dragonflybsd.org /goals/threads.cgi   (1212 words)

Managing Security Context Tokens in a Web Farm (Web Services Technical Articles)   (Site not responding. Last check: 2007-11-01) A security context token (SCT) is a lightweight token that can be established for multiple message exchanges between two endpoints using the protocol defined in the WS-SecureConversation specification. Next we intercept the points at which a token is added and read from the cache, and add logic to persist/retrieve the token from the database. It should always be the case that the token is in the in-memory cache when this method is used, and the used nonce is in-memory. msdn.microsoft.com /library/en-us/dnwebsrv/html/sctinfarm.asp?...   (5551 words)

Use Overview - Resiprocate The actual header method is determined by the header type token passed to the overloaded header method. The rule for determing the header access token from a header as named in RFC3261 is to remove all dashes from the header name and prefix the result with "h_". The class that manages each header type is responsible for parsing header text, providing storage and access during the life of the message, and serializing the header value to text for transmission. warsaw.sjc.purplecomm.com /wiki/index.php?title=Use_Overview   (2332 words)

DragonFly docs List (threaded) for 2006-04   (Site not responding. Last check: 2007-11-01) On http://www.dragonflybsd.org/docs/goals.cgi Serializing tokens may also be used to protect threads from preempting interrupts that attempt to obtain the same token. It is important to note that token atomicity is maintained through preemptive conditions, even though preemption involves a temporary switch to another thread. As I understand things the above text explains the difference between using serializing tokens and BGL when dealing with preemption, and says that with tokens there is not need for spl(). leaf.dragonflybsd.org /mailarchive/docs/2006-04/msg00000.html   (203 words)

[No title]   (Site not responding. Last check: 2007-11-01) When serializing an instance, the module will append a special attribute to the constructor values in order to allow deserialization. I{What attributes are serialized ?} By default, when serializing an instance, every attribute starting by at least one "_" is ignored, even if Python considers it public. B{Important note : the module serializes the class and the module.} B{Apart from testing purposes, serializing classes belonging to the} B{__main__ module is not a good idea.} Here's how to restore your object : >>> deserializedInstance = XMLSerializer.load(open("/tmp/some_file.xml")) Alternatively, you could use I{loads} and I{dumps} which operate on strings. eleves.ec-lille.fr /~perezf/python/xmlserializer/xmlserializer.py   (1099 words)

DragonFly docs List (threaded) for 2006-04 > > > > On http://www.dragonflybsd.org/docs/goals.cgi > > Serializing tokens may also be used to protect threads from preempting > > interrupts that attempt to obtain the same token. It is > > important to note that token atomicity is maintained through > > preemptive conditions, even though preemption involves a temporary > > switch to another thread. "It is not necessary to enter a spl() level or critical section to preserve token atomicity." That sentence is implying that there is an spl level in the kernel (which does not exist), as well as implying that there is a critical section in the kernel (which does exist). leaf.dragonflybsd.org /mailarchive/docs/2006-04/msg00001.html   (303 words)

Method, system and program products for serializing replicated transactions of a distributed computing environment - ... Although, the transactions do not require that any locks related to the access tokens be obtained prior to initiation, transactions which access the same exclusive access tokens are serialized. In accordance with an aspect of the present invention, a serialization technique is provided that allows for transactions using the same resources to be initiated in parallel. But in the case in which tokens do conflict, the serialization technique of the present invention is performed in order to preserve the consistency of the data in each member of the processing server group. www.freepatentsonline.com /6823356.html   (8376 words)

Mike's Weblog   (Site not responding. Last check: 2007-11-01) The LWKT scheduler guarantees that a running thread is not preempted by any other thread holding the same serializing token. If a thread blocks or yields (= giving up it’s time-slice), then the LWKT scheduler is allowed to run a thread that has a serializing token in common with the blocking or yielding thread (or one with no token in common). Thus, when a thread blocks or yields, it automatically leaves it’s critical section until it is running again, and it is responsible for all possible harm that may result due to leaving the critical section. www.ntecs.de /blog-old/Blog/SerializingTokens.rdoc/style/print   (254 words)

Re: [Serial] I18N WG last call comments from Jonathan Robie on 2004-10-26 (public-qt-comments@w3.org from October 2004) The default for serializing a sequence of > tokens defined by XML Schema pretty much has to be the format defined by > XML Schema, or else XML processors won't be able to read serialized > documents. > > Linguistic tokens and delimiters are not the same as computerlanguage > tokens and delimiters. If you want a different serialization, you can use string > manipulation to create whatever you want, but an XML Schema processor > won't be able to recognize the tokens. lists.w3.org /Archives/Public/public-qt-comments/2004Oct/0067.html   (588 words)

Use of JTextPane in Chatting Application Have a look at http://mindprod.com/projects/javapresenter.html What I have effectively done is create tokenized form of HTML that I render myself with colours and fonts. Most of the code is concerned with rendering no more than the narrow band requested, and rapidly finding the data for that band to render. */ private int startAtLineNumber; /** * Array of tokens to render */ private Token[] tokens; /** * Total lines of text in the entire array of Tokens, which is considerably * smaller than the total number of tokens. www.codecomments.com /message591615.html   (2311 words)

Behold WSE 2.0: Removing Another Layer of WS-Pain   (Site not responding. Last check: 2007-11-01) To properly pass the user token, the client must create an instance of the UsernameToken type, populate it with the correct username and password, and somehow indicate to the client-side run time that it must be serialized to the outgoing message. The latter requires that you add the token to a global cache where the WSE run time looks to collect all tokens and signatures for serializing messages to fit policy. Using the global cache is an alternative to adding tokens directly to the Web service proxy class, which I'll use later when I need to deal with a more complicated security scenario. www.devx.com /codemag/Article/21106/0/page/5   (636 words)

wiki:parser Lexer1): scans 2) from a DokuWiki document and outputs a sequence of “tokens” 3), corresponding to the syntax in the document Handler4): receives the tokens from the Lexer and transforms them into a sequence of “instructions” 5). The Handler is a class providing methods which are called by the Lexer as it matches tokens. wiki.splitbrain.org /wiki:parser?do=export_html   (5103 words)

PERFORCE change 85416 for review Memory allocated for these records are never - * freed - */ -static LIST_HEAD(, au_record) bsm_free_q; - -/* - * Lock for serializing access to the list of audit records. Write out the tokens to the record memory. The audit tokens - * that are generated depend on the command that was sent into the - * auditon() system call. lists.freebsd.org /pipermail/p4-projects/2005-October/008925.html   (418 words)

Index   (Site not responding. Last check: 2007-11-01) This class is a PersistenceDelegate for serializing DynamicGridContainers. Replaces the tokens in a String with corresponding values. This class is a PersistenceDelegate for serializing SpringContainers. www.ninetyfourwest.com /DownloadData/javadoc-BuoyX/index-all.html   (2265 words)

CoDe Magazine - Article: Behold WSE 2.0: Removing Another Layer of WS-Pain WSE 1.0 supported a few core facets of the initial WS-Security specification; we were able to sign and encrypt messages with username token or digital signatures. One of the primary goals of the WS-Security specification is to provide an open specification that can support cross-platform security tokens and encryption standards. WSE 2.0 still supports username and X.509 tokens, but also adds support for Kerberos, security contexts compliant with WS-SecureConversation and WS-Trust, and extensibility to support XrML and SAML for single sign-on solutions. www.code-magazine.com /article.aspx?quickid=0405061&page=3   (1458 words)

DragonFly BSD Digest » Blog Archive » Wikipedia entry This entry was posted on Sunday, April 11th, 2004 at 9:56 pm and is filed under Goings-on. As to your issue with the serializing token section, you’re right, a better explaination is required, and is being worked on. Here’s looking forward to the clarification on the tokens; I’ll probably have to wait for the inevitable _Design_and_Implementation_ before I’ll ever keep a handle on it all. www.shiningsilence.com /dbsdlog/index.php/2004/04/11/344.html   (678 words)

Java Help - Use of JTextPane in Chatting Application * first token to render in a given band. * @return first token index that needs to be rendered. * @return last token index that needs to be rendered. www.codecomments.com /archive251-2005-9-591615.html   (1319 words)

And the Rest . . . Represents a file handle (or descriptor) to an open file or an open socket. Breaks the contents of a stream into tokens. Tokens are the smallest unit recognized by a text-parsing algorithm (such as words, symbols, and so on). www.itee.uq.edu.au /~peters/java/tutorial/essential/io/rest.html   (314 words)

[Twisted-commits] r15735 - implement and test ICopyable adapters, for serializing third-party classes + 'copier' must be a callable which accepts an instance of the class you + want to serialize, and returns a tuple of (typename, state_dictionary). Therefore you must be careful about how much state - inspection you perform within this method.""" - - stateSchema = interface.Attribute("""I return an AttributeDictConstraint - object which places restrictions on incoming attribute values. These - restrictions are enforced as the tokens are received, before the state is - passed to setCopyableState.""") - - -CopyableRegistry = {} -def registerRemoteCopy(typename, factory, registry=None): - """Tell PB that 'factory' can be used to handle Copyable objects that - provide a getTypeToCopy name of 'typename'. twistedmatrix.com /pipermail/twisted-commits/2006-January/016234.html   (943 words)

Try your search on: Qwika (all wikis)

About us   |   Why use us?   |   Reviews   |   Press   |   Contact us   Copyright © 2005-2007 www.factbites.com Usage implies agreement with terms.