 |
Faster than a speeding bullet: LANL Roadrunner makes TIME Top Ten list ...
... of technology for 2008: Yes, the LANL Roadrunner (see disclaimer for name usage) is number 10 on TIME magazine's "Best Inventions of 2008" list:
On May 26, at 3:30 in the morning, a $133 million supercomputer nicknamed Roadrunner broke the long-sought-after petaflop barrier: 1 quadrillion calculations per second. Built by IBM for Los Alamos National Laboratory, Roadrunner will be used primarily to simulate the effects of aging on nuclear weapons. Next up: the exaflop barrier.
The other nine before LANL Roadrunner:
- The Retail DNA Test.
- The Tesla Roadster.
- The Lunar Reconnaissance Orbiter.
- Hulu.com.
- The Large Hadron Collider.
- The Global Seed Vault.
- The Chevy Volt.
- Bullets That Shoot Bullets.
- The Orbital Internet.
LANL Roadrunner takes a Tekne Award
A win for superior computing in Minnesota: IBM-Rochester received a Tekne Award for the LANL Roadrunner supercomputer (see disclaimer for name usage). Specifically, the company won the IT-Software & Hardware, Communications and Infrastructure award for the hybrid that is the first computer to break the petaflop barrier. (A Tekne Award acknowledges companies and individuals who have demonstrated superior technology advancement and leadership in Minnesota. There is no requirement that this superiority has to also manifest itself outside of MN, but it usually does.)
Catching up with LANL Roadrunner?
Is Cray closing in?: Oak Ridge National Labs just tested its newly installed AMD-based Cray XT5 supercomputer ("Jaguar") and it peaked out at 1.64pflops, just under the 1.7pflops peak for the Cell/B.E.-/Opteron hybrid LANL Roadrunner (see disclaimer for name usage), in essence making it the world's fastest computer for (non-military) science research.
Categories
: [ Cell | news ]
Nov 11 2008, 12:17:00 PM EST
Permalink
|
Design on a dime: Folding@home awarded for its good design
PS3 at heart of distributed, sharing system: The StanfordU Folding@home project has just grabbed the Japanese Ministry of International Trade and Industry's Good Design Award for outstanding design in industrial and consumer products. (Folding@home is a distributed PS3 network, chock full of Cell/B.E. processors and visualizer software, designed to let users share idle PS3 time with scientists studying protein folding.) According to the jury: "Analysis of proteins for the purpose of shedding light on diseases is just one example of solution design for social issues, a stance that indicates the direction that design should take in the future. Motivating the people who will be involved in these studies will be the key to success, but the program functions well as an idea for making participation in this project visible on a global scale."
Categories
: [ Cell | news ]
Nov 11 2008, 12:14:00 PM EST
Permalink
|
Games people play: Two perspectives on simulation performance
Per cost and raw performance: In the excellent ars technica thinkpiece "Putting the PS3's brain to work," Matt Ford details an article from the Journal of Physical Review E: Statistical, Nonlinear, and Soft Matter Physics ("Accuracy of the lattice-Boltzmann method using the Cell processor") that discusses the computer simulation transition from faster and faster single processors to large multiprocessing systems. The article compares how two Cell/B.E. systems -- the PS3 (best performance per cost) and an IBM QS20/QS21 blade server (best for raw performance) -- handles simulations. The group was trying to determine whether the Cell/B.E. processor's inability to accurately represent floating-point numbers caused a significant loss of precision in the simulations.
(Lattice Boltzmann is a relatively new simulation technique for complex fluid systems. Traditional methods solve the conservation equations of macroscopic properties -- mass, momentum, and energy -- numerically; LB models the fluid consisting of fictive particles and such particles perform consecutive propagation and collision processes over a discrete lattice mesh. Because of its particulate nature and local dynamics, LB has advantages in dealing with complex boundaries, incorporating of microscopic interactions, and parallelization of the algorithm.)
Categories
: [ Cell | news | papers ]
Nov 11 2008, 12:12:00 PM EST
Permalink
|
Trends and tradeoffs: YDL says hello to Fixstars Solutions
Terra Soft becoming part of Fixstars: Terra Soft Solutions (Yellow Dog Linux) and Fixstars (a company specializing in Cell/B.E. software) announced that Terra Soft has been bought by Fixstars and will be known as Fixstars Solutions. Many YDL users are acquainted (at least peripherally) with TSS's CEO Kai Staats; Staats will continue on as Fixstars Solutions's COO. The original Fixstars provided Cell/B.E.-based solutions in Japan using YDL, so the company thought it might be a good match to bring YDL development into the fold. The new company will continue work on Linux for the Power architecture with a primary focus on Cell/B.E. systems.
Categories
: [ Cell | news ]
Nov 11 2008, 12:10:00 PM EST
Permalink
|
Product watch: Toshiba's upscaling TV
Cell/B.E. speed makes HD TV prettier: Why are we talking about television? Because the heart of the Toshiba Regza 42ZV555D and 46ZV555D TVs -- the first "upscaling" TVs according to the company -- is the Cell Broadband Engine processor.
What's "upscaling"? HD TVs have something called an upscaler built in -- what it does is convert video that is shot at a different resolution to the screen to fit the screen (if you didn't, you'd get a small picture in the center of a big screen). The upscaling hardware:
- Stretches the picture to fit.
- Applies video processing to make the picture look as good as possible.
- Applies processing to convert standard-definition, interlaced pictures into progressive ones because LCD and plasma TVs can only display a progressive image. (With an interlaced image, you see the odd lines then the even ones; with a progressive image, you see all the lines sweeping left to right at the same time.)
Where does the Cell/B.E. processor come in? Faster processing, better quality.
Categories
: [ Cell | news ]
Nov 11 2008, 12:08:00 PM EST
Permalink
|
From the Cell/B.E. Architecture forum
This blog-based column looks at some of the more interesting problems and challenges posed recently in the Cell Broadband Engine Architecture forum.
jlabellan84 wants to know if SDK 3.0 apps will play nice with SDK 3.1: I have two questions about SDK3.1:
- Are there problems with backward compatibility? That is, will my applications developed in SDK3.0 run in SDK3.1? and my ALF applications?
- Is it possible to update my PS3 with SDK3.1?
[IBM SDK Service Administrator]: Yes, 3.0 applications will run on 3.1. While we have not done testing on PS3s, it should work the same as 3.0.
|
Can you answer this one? Does the PS3 Cell/B.E. support all of the Security SDK features? Answer.
|
redMoon started this in September 2008 when he asked for help to install SDK 3.0 on a PS3 with Fedora Core 8. There are now three forum pages of troubleshooting advice, including whether all the ISOs have been mounted (and how you tell); how to do some manual installation; device file name changes; why installing numactl and blas is important; the whys of using ppu-embedspu instead of embedspu; and more.
Can you answer this one? What's a difference between a get with barrier (GETB) and a get with fence (GETF)? Answer.
|
People still want to know more about how to install simulator.sdk on Ubuntu: Back in June, iamrohitbanga wanted to know a definitive solution to converting rpm files to debian so he could install the SDK simulator. jgrossm1 suggested IBM Cell SDK/SDK for Multicore Acceleration on Debian/Ubuntu HOWTO. mkistler suggested that "In my experience, the message error while loading shared libraries: libtcl8.4.so: cannot open shared object file: No such file or directory means that the loader could not find libtcl8.4.so when it is trying to load the shared libraries needed by the simulator executable. Is the directory containing libtcl8.4.so in your LD_LIBRARY_PATH?"
The latest in the saga from kauboyhere: I get the same error as mentioned by iamrohitbanga. I installed systemsim-cell 3.0 from its .rpm package using Alien, on Ubuntu 8.04; when I tried ../run_gui from systemsim-cell/run/cell/linux in the Terminal, I got the /opt/ibm/systemsim-cell/bin/systemsim-cell: error while loading shared libraries: libtcl8.4.so: cannot open shared object file: No such file or directory error, as mentioned earlier. I was able to locate the libtcl8.4.so file in my /usr/lib directory. Any solution? tcl8.4 and tk8.4 are installed already.
[choosyg]: I also had serious troubles converting the rpms to deb packages on Hardy, it seems to be a problem with alien/dpkg. Finaly i installed Gutsy and the very same script worked out well. Then i was able to install the simulator deb packages on Hardy and it works fine.
Now the simulatro works, but using spu-gcc failes with the following Message:
/opt/cell/toolchain/bin/spu-gcc -W -Wall -Winline -Wno-main -I. -I
/opt/cell/sysroot/usr/spu/include -I
/opt/cell/sysroot/opt/cell/sdk/usr/spu/include -O3 -c wavelet_spu.c
/tmp/ccxZAQnm.s: Assembler messages:
/tmp/ccxZAQnm.s:7: Error: alignment not a power of 2
/tmp/ccxZAQnm.s:11: Error: no such instruction: `hbrr .L8,printf'
/tmp/ccxZAQnm.s:12: Error: no such instruction: `stqd $80,-16($sp)'
/tmp/ccxZAQnm.s:13: Error: no such instruction: `il $80,0'
...
The same program/makefile workes fine on my Fedora 7 System with Simulator.
|
Can you answer this one? Is there any way to trace SPUs with C++ code? Answer.
|
Panajev2001a wants to know what environmental variable SPE_START_DEBUG does (in reference to gdb debugging).
[IBM SDK Service Administrator]: Information I found:
SPU_DEBUG_START and SPU_INFO were used to set the newly created SPU threads in a sleep state after creation. libspe2 then displayed a message how to connect to the SPU thread with spu-gdb via stderr. Today's combined debugger has different ways to attach to newly created SPU threads. For example GDB has a new command set spu stop-on-load [on|off]. With this set to on the newly created SPU thread is also stopped by GDB itself.
The code for SPU_DEBUG_START and SPU_INFO is still in libspe2 to support the libspe1-to-2 wrapper. So if you set these variables it should show the original behavior of stopping then SPU threads. But this is something that has not been tested (or supported) since the combined debugger was released.
|
Forum statistics for October 2008 Threads: 65 | Participants: 4,160 | Replies: 309 | % threads answered: 17%
|
Categories
: [ Cell | forums ]
Nov 10 2008, 12:01:00 PM EST
Permalink
|
Cell/B.E. Security SDK: APIs: PPE-assisted functions
|
Cell/B.E. Security SDK: APIs: PPE-assisted functions
|
INFObomb
|
|
A quick read on four PPE-assisted function topics in the Security SDK 3.0.
|
|
More INFObombs
|
|
|
|
|
|
PPE-assisted functions are SPE C library functions serviced by the PPE control plane processor in order to improve SPE functionality; we will look at these four topic areas:
change_ppuassist_buf_len.
Unsupported libc.a functions.
Unsupported libgloss.a functions.
Limited support libc.a functions.
Let's take a closer look at these functions.
A little description of PPE-assisted functions
PPE-serviced SPE C library functions are described like the following in chapter 4.1 of "Cell Broadband Engine SDK Libraries Overview and Users Guide":
SPE C library functions ... are serviced by the PPE control plane processor. These functions
have been provided to improved SPE functionality and should not be used for high-performance applications.
These subroutines all operate in the same basic fashion.
- The SPE constructs a local store image of the input and outout parameters.
- The SPE creates a 32-bit message consisting of an opcode and pointer to the local store parameter image array.
- The SPE executes a Stop and Signal instruction.
- The PPE detects the Stop and Signal.
- The PPE invoke a specialist to service the request according to the message opcode.
- The PPE services the requested function.
- The PPE returns results in the local store image array.
- The PPE resumes SPE execution.
- The SPE returns that results back to the caller.
The PPE services to support the standard function documented [in this document] have been incorporated in the SPE runtime
library libspe. As such, no special PPE programming need be done in order to facilitate these functions.
However, the implementation does not operate as described
when the application is executing in the isolation mode due to environment differences. Analogous
replacement functions for the SPE functions are provided in libisolation.a which work around
these differences and provide equivalent function. Note that restrictions described apply
only to PPE-serviced C library functions; SPE-serviced C library functions operate as normal.
The replacement functions make use of an auxiliary buffer which is located in the area of LS reserved
for system use (LS address range 0x3E000-0x3E0C0). The size of auxiliary buffer is initially 192
bytes, but the size may be changed using the change_ppuassist_buf_len function.
Buffer size can be set to no more than 8016 bytes, thus placing a limit on the combined size of function
parameters. This implies that it is not possible to fread()/fwrite() more than ~7900 bytes
at a time and it is not possible to printf more than ~7900 bytes of data at a time.
The size of auxiliary buffer must be at least as large as the sum of the following:
- 16 bytes,
- 16 bytes for each function parameter,
- for each string, array, or struct referenced, the size in bytes of the referenced item rounded up to
the next multiple of 16 bytes, and
- for
printf, fprintf, vprintf, and vfprintf, an additional 32 bytes.
For example, consider the function call
printf(“This is a %s call with %d parameters.\n”, “PPE-assisted call”,
(int) 3);
This call has three parameters -- two strings and one integer. The format string requires 48 bytes and the
parameter string requires 32 bytes. An additional 32 bytes are required for the printf function. The total
buffer size required for the call is
size of auxiliary buffer = 16 + 3*16 + (48 + 32) + 32 = 176 bytes
If size of auxiliary buffer was set to an insufficient value, a PPE-assisted call will terminate early with
errno variable set to ENOBUFS.
Developers must ensure that when invoking such a PPE-assisted call, they have no outstanding DMAs
with their source and/or destination overlapping with auxiliary buffer -- this is to avoid incorrect execution of a
PPE-assisted call and/or DMA.
PPE-assisted functions that are unsupported in emulated isolation mode will produce a missing link
error at application build time by using stubs which link to a non-existent function.
To use PPE-serviced calls in emulated isolation mode, libisolation.a must be linked after libc.a and
libgloss.a, but only after defining the symbol __send_to_ppe as being wrapped (redefined to
__wrap___send_to_ppe) at link time. Including make.iso.footer in the makefile will resolve the correct
linkage steps.
change_ppuassist_buf_len
The change_ppuassist_buf_len function sets the size of the buffer area to be used for PPE-assisted
functions. These are the functions that require assistance from code that executes on the
PPE. Parameters to the PPE code are passed using a buffer in the area of LS reserved for system
use (LS address range 0x3E000-0x3E0C0); results are returned using the same buffer. Since
this buffer competes with other uses for this reserved area of LS, this function can be used to set
the size of the buffer smaller when not needed or larger for larger parameters (for example, for large strings).
Minimum and maximum sizes buffer can be set to 80 and 8016 bytes. Value of 0 is
returned on successful change or -1 is returned on failure.
C specification
#include <libisolation.h>
int change_ppuassist_buf_len(unsigned int new_len)
Dependencies
None.
Unsupported libc.a functions
These 15 PPE-assisted functions from libc.a are not supported in isolation mode:
gets
fscanf
scanf
setbuf
setvbuf
snprintf
sprintf
sscanf
tmpnam
vfscanf
vscanf
vsnprintf
vsprintf
vsscanf
system
Unsupported libgloss.a functions
These 15 PPE-assisted functions from libgloss.a are not supported in isolation mode:
ftok_ea
mmap_ea
mremap_ea
msync_ea
munmap_ea
shmat_ea
shmctl_ea
shmdt_ea
shmget_ea
shm_open
shm_unlink
mktemp
utimes
readv
writev
Limited support libc.a functions
These four PPE-assisted functions from libc.a have limited support in isolation mode. This support
is limited as the types of arguments are determined by scanning the format string; if the format string is
wrong or does not match the argument types, then it is possible to leak information.
fprintf
printf
vfprintf
vprintf
An additional limitation is that conversion character %n is not supported. This is the conversion
character that makes *printf functions write back the number of characters written so far into original
parameter list.
Taken from the Cell BE Security SDK v3.0 Installation and User's Guide. Download the SDK. Check out some reference guides in the Cell Resource Center SDK library.
|
|
|
|
|
|
ORIGINAL DOCUMENTATION | DOWNLOAD SDK |
SDK LIBRARY |
MORE INFObombs |
BACK to BLOG |
BACK to ZONE
|
|
|
Categories
: [ Cell | infobombs ]
Nov 10 2008, 12:00:00 PM EST
Permalink
|
It came from the Lab: Don't eat so much CO2
Cell to reduce greenhouse gases via fast sims: IBM and USaskatchewan are collaborating to understand better how to limit carbon dioxide emissions from coal-fired electricity plants -- they're doing this by setting up a simulation system consisting of BladeCenter QS22 Cell/B.E. blades. USaskatchewan research lead Raymond Spiteri noted that such simulations -- including determining how the plants can be modified to harness pre-released CO2 and change it into benign by-products or other fuels like methanol -- "used to take 10 days to complete ..." because the university rented time on a system to run the results. Now the results "will now be completed in under one day ... getting results back faster enables us to be more ambitious in our simulations and try more ideas and different scenarios." Spiteri has already started working with IBM scientists to build a model for relevant chemical reactions and to craft algorithms and code for the Cell/B.E. processors.
Categories
: [ Cell | news ]
Nov 04 2008, 11:25:00 AM EST
Permalink
|
Oddments: What the world will look like ...
when robots take your job: Electrical engineer Marshall Brain (also founder of How Stuff Works) thinks robots may put us out of work in the next 20 to 30 years. At the recent Singularity Summit, Brain claimed that the coming industrial revolution will probably realize the fear that the original Industrial Revolution didn't -- that a "second intelligent species" may be a disruptive technology, at least to the human economy. But he's not trying to hold back the coming tide. Brain suggests we restructure the economy before this happens to make it beneficial for all, humans and robots. For example, distribute the benefits of the revolution to every person via a US$25K-year stipend. (He's also proposed some other interesting ideas to remove "dysfunctional elements from the capitalistic system.")
when robots take your dog's job too!: GATech researcher hope to reduce the cost and availability problems in the service dog industry by designing a robot to handle those tasks. The researchers claim that there are never enough service dogs to go around, they cost about US$16K a piece, and it takes about two years to train them. Phase One of their research yielded a point-and-click laser the user can use to point out the object to be fetched. The robot dogs already respond to a range of verbal commands, so the initial prototype was built with off-the-shelf robotic parts with a custom manipulator that mimics a dog's mouth.
Categories
: [ events | general | news ]
Nov 04 2008, 11:21:00 AM EST
Permalink
|
Cell/B.E. Security SDK: APIs: Data transfer
|
Cell/B.E. Security SDK: APIs: Data transfer
|
INFObomb
|
|
A quick read on four data-transfer functions in the Security SDK 3.0.
|
|
More INFObombs
|
|
|
|
|
|
To enable data transfer through the open area of local store on an SPU, we will look at four data-transfer functions:
copyin.
copyout.
decrypt_in.
encrypt_out.
As described in the Cell/B.E. Security architecture document, when an
SPU is in hardware isolation mode, there is an open area of LS much like a "window" through which an
application can DMA in and out data. The previously listed functions assist the programmer with this
programming model. copyin/copyout allow users to transfer data between main memory
and LS via the open area. decrypt_in/encrypt_out are based on copyin/copyout but
additionally they apply an XOR mask to the data to mimic encryption.
For programmers who intend to only use the emulated isolation mode, you do not need to use these
functions -- they are only for programmers who eventually want to move up to using the hardware
isolation mode.
Let's take a closer look at these functions.
copyin
The copyin subroutine copies data from the main memory into the LS. ea and ls must be 16-byte aligned and size must be a multiple of 16 bytes. If all data are successfully transferred to the LS, this subroutine returns success as a value of 0; otherwise, it returns an error as -1.
C specification
#include <libisolation.h>
int copyin(uint64_t ea, void *ls, uint32_t size)
Dependencies
None.
copyout
The copyout subroutine copies data from LS to the main memory. ea and ls must be 16-byte aligned and size must be a multiple of 16 bytes. If all data are successfully transferred to the main memory, this subroutine returns success as a value of 0; otherwise, it returns an error as -1.
C specification
#include <libisolation.h>
int copyout(uint64_t ea, void *ls, uint32_t size)
Dependencies
None.
decrypt_in
The decrypt_in subroutine copies the message on ea into dst_ls and XORs the message at dst_ls with a library static mask. The XOR'd results are stored in dst_ls. ea and dst_ls must be 16-byte aligned and message_size must be a multiple of 16 bytes. shared_key is ignored in this release. If all data are correctly XOR'd into the LS, it returns success as value 0; otherwise, this subroutine returns errors.
C specification
#include <libisolation.h>
int decrypt_in(void *dst_ls, const uint64_t ea, const uint32_t message_size,
const vector unsigned char shared_key)
Dependencies
copyin.
encrypt_out
The encrypt_out subroutine XOR's the message at src_ls with a library static mask and copies the XOR'd message to ea. ea and src_ls must be 16-byte aligned and message_size must be a multiple of 16 bytes. shared_key is ignored in this release. If all data are correctly XOR'd and copied out from the LS, it returns success (0). Otherwise, this subroutine returns errors.
C specification
#include <libisolation.h>
int encrypt_out(const uint64_t ea, void *src_ls, const uint32_t
message_size, const vector unsigned char shared_key)
Dependencies
copyout.
Taken from the Cell BE Security SDK v3.0 Installation and User's Guide. Download the SDK. Check out some reference guides in the Cell Resource Center SDK library.
|
|
|
|
|
|
ORIGINAL DOCUMENTATION | DOWNLOAD SDK |
SDK LIBRARY |
MORE INFObombs |
BACK to BLOG |
BACK to ZONE
|
|
|
Categories
: [ Cell | infobombs ]
Nov 03 2008, 12:01:00 PM EST
Permalink
|
Cell/B.E. Security SDK: APIs: Secure File Storage
|
Cell/B.E. Security SDK: APIs: Secure File Storage
|
INFObomb
|
|
A quick read on seven SFS functions in the Security SDK 3.0.
|
|
More INFObombs
|
|
|
|
|
|
To enable reading, writing, and verifying sensitive information to an encrypted file, we will look at these seven Secure File Storage functions:
SFS_FILE *.
sfs_fopen.
sfs_fclose.
sfs_fread.
sfs_fwrite.
sfs_fseek.
sfs_ftell.
The Secure File Storage APIs provide a facility for reading and writing sensitive information to an
encrypted file with the added function that the content is verified after reading so that any tampering
is detected. The Secure File Storage APIs mirror fopen and fread/fwrite for file streams, but with a
slightly more limited set of semantics; in particular, not all of the file APIs are supported for the
encrypted files.
When a secure file is created or opened, an encryption key is provided. Files may be shared between
applications by sharing the encryption key. If the file is not to be shared, then the encryption key must
be kept secret; this may be best done by encrypting the key as part of the encrypted section of the
secure SPE application.
Let's take a closer look at these functions.
SFS_FILE *
The SFS_FILE * pointer is the Secure File Storage analog of the FILE * for file I/O. It references
a structure that is allocated, maintained, and freed by the Secure File Storage APIs and it contains
all of the information necessary to access the Secure File Storage.
C specification
#include <libisolation.h>
SFS_FILE *sfs_file_var;
Dependencies
None.
sfs_fopen
sfs_fopen creates or opens the Secure File Storage file associated with the string filename and
associates a stream, referenced by the SFS_FILE structure, with the file.
The argument mode is interpreted as if for an fopen call to stdio; it must point to a string
beginning with one of the following sequences:
r -- Open the file for reading. The stream is positioned at the beginning of the file. It is an error
if the file does not exist.
r+ -- Open the file for reading and writing. The stream is positioned at the beginning of the file. It
is an error if the file does not exist.
w -- Open the file for writing. Truncate an existing file or create a new file. The stream is
positioned at the beginning of the file.
w+ -- Open the file for writing and reading. Truncate an existing file or create a new file. The
stream is positioned at the beginning of the file.
a -- Open the file for writing. The file is created if it does not exist. The stream is positioned at
the end of the file and all writes occur at the end of the file.
a+ -- Open the file for writing and reading. The file is created if it does not exist. The stream is
positioned at the end of the file and all writes occur at the end of the file.
The argument key points to a vector of unsigned characters which contains the 16-character
encryption key. This key is used for all encryption and decryption of the Secure File Storage.
During the open of the encrypted file, sfs_fopen reads the file header and verification data and
may write additional verification data. As a result of these operations, sfs_fopen may set errno to
any of the error codes associated with fopen, fread, and fwrite; it may also set errno to EINVAL
if the encryption key can not correctly decrypt the file header; or to EIO if the verification data does
not correctly verify.
C specification
#include <libisolation.h>
SFS_FILE *sfs_fopen(char *filename, char *mode,
const vector unsigned char key);
Dependencies
None.
sfs_fclose
sfs_fclose closes the Secure File Storage associated with stream. If the stream is open for writing,
any buffered data is first written to the file.
sfs_fclose returns 0 if successful, EOF otherwise. In either case, no further access to the stream is
allowed.
During this operation, sfs_fclose updates the file header and verification data if the file was open
for writing. As a result of these operations, sfs_fclose may set errno to any of the error codes
associated with fwrite and fclose.
C specification
#include <libisolation.h>
int sfs_fclose(SFS_FILE *stream);
Dependencies
None.
sfs_fread
sfs_fread will read count elements from the stream, each of size element_size, into the memory
referenced by buffer. If less than count elements are remaining in the stream, then fewer bytes
will be returned. If the number of remaining bytes is not a multiple of element_size, then an error
is returned.
Upon successful completion, sfs_fread returns the number of elements of size element_size that
were read and returned. The stream location is incremented by the number of bytes returned.
As part of this operation, sfs_fread reads both the requested data and the associated verification
information. sfs_fread may return with errno set to any of the error codes associated with fread.
In addition, if the verification data does not agree with the computed verification over the
requested data, then sfs_fread returns with errno set to EIO.
C specification
#include <libisolation.h>
int sfs_fread(void *buffer, size_t element_size, size_t count,
SFS_FILE *stream);
Dependencies
None.
sfs_fwrite
sfs_fwrite will write count elements to the stream, each of size element_size, from the memory
referenced by buffer.
sfs_fwrite returns the number of elements written. If the return value is less than count, then a
write error occurred.
During this operation, sfs_fwrite writes the data to the encrypted file and computes the new
verification data. As a result of these operations, sfs_fwrite may set errno to any of the error
codes associated with fwrite.
C specification
#include <libisolation.h>
int sfs_fwrite(void *buffer, size_t element_size, size_t count,
SFS_FILE *stream);
Dependencies
None.
sfs_fseek
sfs_fseek sets the current stream location to that specified by offset. The interpretation of offset is
determined by wherefrom.
SEEK_SET -- Interpret offset as an absolute offset from the start of the file.
SEEK_CUR -- Interpret offset as a relative offset from the current stream location.
SEEK_END -- Interpret offset as a relative offset from the stream position immediately
following the last data byte in the file.
If successful, sfs_fseek returns 0; otherwise, sfs_fseek returns -1. sfs_fseek may return with errno
set to any of the error codes associated with fseek.
C specification
#include <libisolation.h>
int sfs_fseek(SFS_FILE *stream, long int offset, int wherefrom);
Dependencies
None.
sfs_ftell
sfs_ftell returns the current position offset within the stream.
If successful, sfs_ftell returns 0 or a positive value; otherwise, sfs_ftell returns -1. sfs_ftell may
return with errno set to any of the error codes associated with ftell.
C specification
#include <libisolation.h>
int sfs_ftell(SFS_FILE *stream);
Dependencies
None.
Taken from the Cell BE Security SDK v3.0 Installation and User's Guide. Download the SDK. Check out some reference guides in the Cell Resource Center SDK library.
|
|
|
|
|
|
ORIGINAL DOCUMENTATION | DOWNLOAD SDK |
SDK LIBRARY |
MORE INFObombs |
BACK to BLOG |
BACK to ZONE
|
|
|
Categories
: [ Cell | infobombs ]
Nov 03 2008, 12:00:00 PM EST
Permalink
|
It came from the Lab: Plasmon lens create denser chips
Plasmonic lithography: UC-Berkeley engineers have found a way to breathe new life into optical lithography called plasmonic lithography -- by using metal lenses that focus light by exciting electrons (plasmons), they've been able to create line patterns 80nm wide or about 10 times smaller. The resolution and defraction you can get with regular light is a limiting factor; to overcome this, they leveraged a property of metals -- the presence of free electrons at the surface that oscillate when exposed to light (evanescent waves, smaller than the wavelength of light).
Categories
: [ general | news ]
Oct 28 2008, 11:57:00 AM EDT
Permalink
|
|
 |
|