 |
級別： 初級
Nam Keung (mailto:namkeung@us.ibm.com), 高級程序員, IBM
Chakarat Skawratananond (mailto:chakarat@us.ibm.com), pSeries Linux 技術(shù)顧問, IBM
2005 年 2 月 10 日
2005 年 4 月 21 日 更新
本系列文章可以幫助您將 Win32 C/C++ 應(yīng)用程序移植到 POWER 上的 Linux。高級程序員 Nam Keung 和 pSeries® Linux 技術(shù)顧問 Chakarat Skawratananond 從互斥（mutex）應(yīng)用程序接口（application program interface，API）的角度闡述了從 Win32 到 Linux 的映射。本系列的 第 1 部分 集中關(guān)注的是 Win32 API 的映射。
介紹
本文關(guān)注的是互斥原語（primitives）。建議您在繼續(xù)閱讀之前先回顧本系列 第 1 部分 中的下列章節(jié)：
互斥
如下面的 表 1 所示，互斥提供線程間資源的獨占訪問控制。它是一個簡單的鎖，只有持有它的線程才可以釋放那個互斥。它確保了它們正在訪問的共享資源的完整性（最常見的是共享數(shù)據(jù)），因為在同一時刻只允許一個線程訪問它。
表 1. 互斥
| Win32 |
Linux |
CreateMutex(0, FALSE, 0); |
pthread_mutex_init(&mutex, NULL)) |
CloseHandle(mutex); |
pthread_mutex_destroy(&mutex) |
WaitForSingleObject(mutex, INFINITE)) |
pthread_mutex_lock(&mutex) |
ReleaseMutex(mutex); |
pthread_mutex_unlock(&mutex) |
創(chuàng)建互斥
在 Win NT/Win2K 中，所有互斥都是遞歸的。
在 Win32 中，CreateMutex() 為當(dāng)前進程中的線程提供資料的獨占訪問控制。此方法讓線程可以串行化對進程內(nèi)資源的訪問。創(chuàng)建了互斥句柄（mutual exclusion handle）后，當(dāng)前進程中的所有線程都可以使用它（見下面的 清單 1）。
清單 1. 創(chuàng)建互斥
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lMutexAttributes,
BOOL lInitialOwner,
LPCTSTR lName
)
|
Linux 使用 pthread 庫調(diào)用 pthread_mutex_init() 來創(chuàng)建互斥，如下面的 清單 2 所示。
清單 2. pthread
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
|
Linux 有三種類型的互斥。互斥類型決定了在 pthread_mutex_lock 中線程嘗試鎖定一個它已經(jīng)持有的互斥時所發(fā)生的情形：
- Fast mutex：
- 當(dāng)嘗試使用
pthread_mutex_lock() 去鎖定互斥時，進行調(diào)用的線程會永遠掛起。
- Recursive mutex：
pthread_mutex_lock() 立即返回成功返回代碼。
- Error check mutex：
pthread_mutex_lock() 立即返回錯誤代碼 EDEADLK。
可以以兩種方式設(shè)置互斥的類型。清單 3 介紹了設(shè)置互斥的靜態(tài)方法。
清單 3. 設(shè)置互斥的靜態(tài)方法
/* For Fast mutexes */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
/* For recursive mutexes */
|
您可以使用這個函數(shù)來鎖定互斥：pthread_mutex_lock(pthread_mutex_t *mutex)。這個函數(shù)會獲得一個指向它正在嘗試鎖定的互斥的指針。當(dāng)互斥被鎖定或者發(fā)生錯誤時，函數(shù)返回。那個錯誤不是歸咎于被鎖定的互斥。函數(shù)會等待互斥被解鎖。
設(shè)置互斥的另一種方式是使用互斥屬性對象。為此，要調(diào)用 pthread_mutexattr_init() 來初始化對象，然后調(diào)用 pthread_mutexattr_settype() 來設(shè)置互斥的類型，如下面的 清單 4 所示。
清單 4. 通過屬性設(shè)置互斥
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);
|
使用下面的函數(shù)解開對互斥的鎖定（見 清單 5）：
這里是創(chuàng)建互斥的示例代碼（見下面的 6 和 7）。
清單 5. 解鎖函數(shù)
pthread_mutex_unlock(pthread_mutex_t *mutex))
|
清單 6. Win32 示例代碼
HANDLE mutex;
mutex = CreateMutex(0, FALSE, 0);
if (!(mutex))
{
return RC_OBJECT_NOT_CREATED;
}
|
清單 7. 相應(yīng)的 Linux 代碼
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
pthread_mutexattr_init (&attr);
if (rc = pthread_mutex_init(&mutex, &attr))
{
return RC_OBJECT_NOT_CREATED;
}
|
銷毀互斥
在 Win32 中，CloseHandle() 方法（見 清單 8）可以刪除為當(dāng)前進程中資源提供獨占訪問控制的對象。刪除那個對象后，那個互斥對象就會無效，直到 CloseHandle() 方法通過調(diào)用 CreateMutex 重新初始化它。
當(dāng)不再對資源進行獨占訪問后，您應(yīng)該調(diào)用這個方法銷毀它。如果您需要放棄那個對象的所有權(quán)，那么應(yīng)該調(diào)用 ReleaseMutex() 方法。
在 Linux 中，pthread_mutex_destroy() 會銷毀互斥對象，這會釋放它可能會持有的資源。它還會檢查互斥在那個時刻是不是解除鎖定的（見清單 9）。
清單 8. Win32 示例代碼
if(WaitForSingleObject(mutex, (DWORD)0) == WAIT_TIMEOUT )
return RC_NOT_OWNER;
CloseHandle(mutex);
|
清單 9. Linux 代碼
if (pthread_mutex_destroy(&mutex) == EBUSY)
return RC_NOT_OWNER;
|
鎖定互斥
在 Win32 中，WaitForSingleObject()（見 清單 10）會阻塞對當(dāng)前進程內(nèi)資源的獨占訪問的請求。進程可以通過下面的方式阻塞請求：
- 如果獨占訪問請求的資源沒有被鎖定，則這個方法鎖定它。
- 如果獨占訪問的資源已經(jīng)被鎖定，則此方法阻塞那個調(diào)用線程，直到那個資源被解除鎖定。
Linux 使用 pthread_mutex_lock()（見 清單 11）。
您還可以使用 pthread_mutex_trylock() 來測試某個互斥是否已經(jīng)被鎖定，而不需要真正地去鎖定它。如果另一個線程鎖定了那個互斥，則 pthread_mutex_trylock 將不會阻塞。它會立即返回錯誤代碼 EBUSY。
清單 10. Win32 示例代碼
if ((rc = WaitForSingleObject(mutex, INFINITE)) == WAIT_FAILED)
return RC_LOCK_ERROR;
|
清單 11. Linux 代碼
if (rc = pthread_mutex_lock(&mutex))
return RC_LOCK_ERROR;
|
釋放或者解鎖互斥
Win32 使用 ReleaseMutex()（見 清單 12）來釋放對資源的獨占訪問。如果進行調(diào)用的線程并不擁有那個互斥對象，則這個調(diào)用可能會失敗。
Linux 使用 pthread_mutex_unlock() 來釋放或者解鎖互斥（見清單 13）。
清單 12. Win32 示例代碼
If (! ReleaseMutex(mutex))
{
rc = GetLastError();
return RC_UNLOCK_ERROR;
}
|
清單 13. Linux 示例代碼
if (rc = pthread_mutex_unlock(&mutex))
return RC_UNLOCK_ERROR;
|
Mutex 示例代碼
這里是獲得進程內(nèi)互斥的 Win32 示例代碼（見 Listing 14）：
清單 14. Win32 示例代碼
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void thrdproc (void *data); //the thread procedure (function) to be executed
HANDLE mutex;
int main( int argc, char **argv )
{
int hThrd;
unsigned stacksize;
HANDLE *threadId1;
HANDLE *threadId2;
int arg1;
DWORD rc;
if( argc < 2 )
arg1 = 7;
else
arg1 = atoi( argv[1] );
printf( "Intra Process Mutex test.\n" );
printf( "Start.\n" );
mutex = CreateMutex(0, FALSE, 0);
if (mutex==NULL)
return RC_OBJECT_NOT_CREATED;
printf( "Mutex created.\n" );
if ((rc = WaitForSingleObject(mutex, INFINITE)) == WAIT_FAILED)
return RC_LOCK_ERROR ;
printf( "Mutex blocked.\n" );
if( stacksize < 8192 )
stacksize = 8192;
else
stacksize = (stacksize/4096+1)*4096;
hThrd = _beginthread( thrdproc, // Definition of a thread entry
NULL,
stacksize,
"Thread 1");
if (hThrd == -1)
return RC_THREAD_NOT_CREATED);
*threadId1 = (HANDLE) hThrd;
hThrd = _beginthread( thrdproc, // Definition of a thread entry
NULL,
stacksize,
Thread 2");
if (hThrd == -1)
return RC_THREAD_NOT_CREATED);
*threadId2 = (HANDLE) hThrd;
printf( "Main thread sleeps 5 sec.\n" );
Sleep( 5*1000 );
if (! ReleaseMutex(mutex))
{
rc = GetLastError();
return RC_UNLOCK_ERROR;
}
printf( "Mutex released.\n" );
printf( "Main thread sleeps %d sec.\n", arg1 );
Sleep( arg1 * 1000 );
if( WaitForSingleObject(mutex, (DWORD)0) == WAIT_TIMEOUT )
return RC_NOT_OWNER;
CloseHandle(mutex);
printf( "Mutex deleted. (%lx)\n", rc );
printf( "Main thread sleeps 5 sec.\n" );
Sleep( 5*1000 );
printf( "Stop.\n" );
return 0;
}
void thread_proc( void *pParam )
{
DWORD rc;
printf( "\t%s created.\n", pParam );
if ((rc = WaitForSingleObject(mutex, INFINITE)) == WAIT_FAILED)
return RC_LOCK_ERROR;
printf( "\tMutex blocked by %s. (%lx)\n", pParam, rc );
printf( "\t%s sleeps for 5 sec.\n", pParam );
Sleep( 5* 1000 );
if (! ReleaseMutex(mutex))
{
rc = GetLastError();
return RC_UNLOCK_ERROR;
}
printf( "\tMutex released by %s. (%lx)\n", pParam, rc );
}
|
相應(yīng)的獲得進程內(nèi)互斥的 Linux 示例代碼（見 清單 15）：
清單 15. 相應(yīng)的 Linux 示例代碼
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
void thread_proc (void * data);
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
int main( int argc, char **argv )
{
pthread_attr_t pthread_attr;
pthread_attr_t pthread_attr2;
pthread_t threadId1;
pthread_t threadId2;
int arg1;
int rc = 0;
if( argc < 2 )
arg1 = 7;
else
arg1 = atoi( argv[1] );
printf( "Intra Process Mutex test.\n" );
printf( "Start.\n" );
pthread_mutexattr_init( &attr );
if ( rc = pthread_mutex_init( &mutex, NULL))
{
printf( "Mutex NOT created.\n" );
return RC_OBJECT_NOT_CREATED;
}
printf( "Mutex created.\n" );
if (rc = pthread_mutex_lock (&mutex))
{
printf( "Mutex LOCK ERROR.\n" );
return RC_LOCK_ERROR;
}
printf( "Mutex blocked.\n" );
if (rc = pthread_attr_init(&pthread_attr))
{
printf( "pthread_attr_init ERROR.\n" );
return RC_THREAD_ATTR_ERROR;
}
if (rc = pthread_attr_setstacksize(&pthread_attr, 120*1024))
{
printf( "pthread_attr_setstacksize ERROR.\n" );
return RC_STACKSIZE_ERROR;
}
if (rc = pthread_create(&threadId1,
&pthread_attr,
(void*(*)(void*))thread_proc,
"Thread 1" ))
{
printf( "pthread_create ERROR.\n" );
return RC_THREAD_NOT_CREATED;
}
if (rc = pthread_attr_init(&pthread_attr2))
{
printf( "pthread_attr_init2 ERROR.\n" );
return RC_THREAD_ATTR_ERROR;
}
if (rc = pthread_attr_setstacksize(&pthread_attr2, 120*1024))
{
printf( "pthread_attr_setstacksize2 ERROR.\n" );
return RC_STACKSIZE_ERROR;
}
if (rc = pthread_create(&threadId2,
&pthread_attr2,
(void*(*)(void*))thread_proc,
"Thread 2" ))
{
printf( "pthread_CREATE ERROR2.\n" );
return RC_THREAD_NOT_CREATED;
}
printf( "Main thread sleeps 5 sec.\n" );
sleep (5);
if (rc = pthread_mutex_unlock(&mutex))
{
printf( "pthread_mutex_unlock ERROR.\n" );
return RC_UNLOCK_ERROR;
}
printf( "Mutex released.\n" );
printf( "Main thread sleeps %d sec.\n", arg1 );
sleep(arg1);
pthread_mutex_destroy(&mutex);
printf( "Main thread sleeps 5 sec.\n" );
sleep( 5 );
printf( "Stop.\n" );
return 0;
}
void thread_proc( void *pParam )
{
int nRet;
printf( "\t%s created.\n", pParam );
if (nRet = pthread_mutex_lock(&mutex))
{
printf( "thread_proc Mutex LOCK ERROR.\n" );
return RC_LOCK_ERROR;
}
printf( "\tMutex blocked by %s. (%lx)\n", pParam, nRet );
printf( "\t%s sleeps for 5 sec.\n", pParam );
sleep(5);
if (nRet = pthread_mutex_unlock(&mutex))
{
printf( " thread_proc :pthread_mutex_unlock ERROR.\n" );
return RC_UNLOCK_ERROR;
}
printf( "\tMutex released by %s. (%lx)\n", pParam, nRet );
}
|
這里是獲得進程間互斥的另一 Win32 示例代碼。
互斥是系統(tǒng)范圍內(nèi)對象，可以由多個進程使用。如果程序 A 創(chuàng)建一個互斥，則程序 B 可以使用同一個互斥。互斥有名稱，并且，一個給定名稱的互斥在同一機器上同一時刻只能存在一個。如果您創(chuàng)建了一個名為“My Mutex” 的互斥，則任何其他程序都不能使用這個名稱創(chuàng)建互斥，如下面的清單 16 和 18 所示。
清單 16. Win32 進程間互斥示例代碼 Process 1
#include <stdio.h>
#include <windows.h>
#define WAIT_FOR_ENTER printf( "Press ENTER\n" );getchar()
int main()
{
HANDLE mutex;
DWORD rc;
printf( "Inter Process Mutex test - Process 1.\n" );
printf( "Start.\n" );
SECURITY_ATTRIBUTES sec_attr;
sec_attr.nLength = sizeof( SECURITY_ATTRIBUTES );
sec_attr.lpSecurityDescriptor = NULL;
sec_attr.bInheritHandle = TRUE;
mutex = CreateMutex(&sec_attr, FALSE, "My Mutex");
if( mutex == (HANDLE) NULL )
return RC_OBJECT_NOT_CREATED;
printf( "Mutex created.\n" );
WAIT_FOR_ENTER;
if ( WaitForSingleObject(mutex, INFINITE) == WAIT_FAILED)
return RC_LOCK_ERROR;
printf( "Mutex blocked.\n" );
WAIT_FOR_ENTER;
if( ! ReleaseMutex(mutex) )
{
rc = GetLastError();
return RC_UNLOCK_ERROR;
}
printf( "Mutex released.\n" );
WAIT_FOR_ENTER;
CloseHandle (mutex);
printf( "Mutex deleted.\n" );
printf( "Stop.\n" );
return OK;
}
|
在此，Linux 實現(xiàn)使用的是 System V Interprocess Communications（IPC）函數(shù)，如清單 17 和 19 所示。
清單 17. 相應(yīng)的 Linux 示例代碼 Process 1
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#define WAIT_FOR_ENTER printf( "Press ENTER\n" );getchar()
union semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* array for GETALL, SETALL */
struct seminfo __buf; /* buffer for IPC info */
};
main()
{
int shr_sem;
key_t semKey;
struct sembuf semBuf;
int flag;
union semun arg;
printf( "Inter Process Mutex test - Process 1.\n" );
printf( "Start.\n" );
flag = IPC_CREAT;
if( ( semKey = (key_t) atol( "My Mutex" ) ) == 0 )
return RC_INVALID_PARAM;
flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
shr_sem = (int) semget( semKey, 1, flag );
if (shr_sem < 0)
return RC_OBJECT_NOT_CREATED;
arg.val = 1;
if (semctl(shr_sem, 0, SETVAL, arg) == -1)
return RC_OBJECT_NOT_CREATED;
printf( "Mutex created.\n" );
WAIT_FOR_ENTER;
semBuf.sem_num = 0;
semBuf.sem_op = -1;
semBuf.sem_flg = SEM_UNDO;
if (semop(shr_sem, &semBuf, 1) != 0)
return RC_LOCK_ERROR;
printf( "Mutex blocked.\n" );
WAIT_FOR_ENTER;
semBuf.sem_num = 0;
semBuf.sem_op = 1;
semBuf.sem_flg = SEM_UNDO;
if (semop(shr_sem, &semBuf, 1) != 0)
return RC_UNLOCK_ERROR;
printf( "Mutex released.\n" );
WAIT_FOR_ENTER;
semctl( shr_sem, 0, IPC_RMID );
printf( "Mutex deleted.\n" );
printf( "Stop.\n" );
return 0;
|
清單 18. Win32 進程間示例代碼 Process 2
#include <stdio.h>
#include <windows.h>
int main()
{
HANDLE mutex;
printf( "Inter Process Mutex test - Process 2.\n" );
printf( "Start.\n" );
SECURITY_ATTRIBUTES sec_attr;
sec_attr.nLength = sizeof( SECURITY_ATTRIBUTES );
sec_attr.lpSecurityDescriptor = NULL;
sec_attr.bInheritHandle = TRUE;
mutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, “My Mutex");
if( mutex == (HANDLE) NULL )
return RC_OBJECT_NOT_CREATED;
printf( "Mutex opened. \n");
printf( "Try to block mutex.\n" );
if ( WaitForSingleObject(mutex, INFINITE) == WAIT_FAILED)
return RC_LOCK_ERROR;
printf( "Mutex blocked. \n" );
printf( "Try to release mutex.\n" );
if( ! ReleaseMutex(mutex) )
return RC_UNLOCK_ERROR;
printf( "Mutex released.\n" );
CloseHandle (mutex);
printf( "Mutex closed. \n");
printf( "Stop.\n" );
return OK;
}
|
清單 19. 相應(yīng)的 Linux 示例代碼 Process 2
#include <stdio.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <unistd.h>
int main()
{
int mutex;
key_t semKey;
struct sembuf semBuf;
int flag;
int nRet=0;
printf( "Inter Process Mutex test - Process 2.\n" );
printf( "Start.\n" );
flag = 0;
if( ( semKey = (key_t) atol( "My Mutex" ) ) == 0 )
return RC_INVALID_PARAM;
flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
mutex = (int) semget( semKey, 1, flag );
if (mutex == -1)
return RC_OBJECT_NOT_CREATED;
printf( "Mutex opened \n");
printf( "Try to block mutex.\n" );
semBuf.sem_num = 0;
semBuf.sem_op = -1;
semBuf.sem_flg = SEM_UNDO;
if (semop(mutex, &semBuf, 1) != 0)
return RC_LOCK_ERROR;
printf( "Mutex blocked. \n");
printf( "Try to release mutex.\n" );
semBuf.sem_num = 0;
semBuf.sem_op = 1;
semBuf.sem_flg = SEM_UNDO;
if (semop(mutex, &semBuf, 1) != 0)
return RC_UNLOCK_ERROR;
printf( "Mutex released. \n");
printf( "Mutex closed. \n");
printf( "Stop.\n" );
return 0;
}
|
結(jié)束語
在本文中，我們介紹了互斥 API 從 Win32 到 Linux 的映射。我們還引用了一系列互斥示例代碼來幫助您進行從 Win32 到 Linux 的遷移行動。本系列的下一篇文章將闡述信號量。
補充聲明
IBM Corporation 1994-2005。保留所有權(quán)利。
本文檔中對 IBM 產(chǎn)品或服務(wù)的引用并不表示 IBM 想要讓它們在所有國家都可用。
IBM、eServer 和 pSeries 是 IBM Corporation 在美國和／或其他國家或地區(qū)的商標(biāo)。
Microsoft、Windows、Windows NT 和 Windows 徽標(biāo)是 Microsoft Corporation 在美國和／或其他國家或地區(qū)的商標(biāo)或注冊商標(biāo)。
Intel、Intel Inside（logos）、MMX 和 Pentium 是 Intel 公司在美國和／或其他國家或地區(qū)的商標(biāo)。
UNIX 是 The Open Group 在美國和其他國家或地區(qū)的注冊商標(biāo)。
Linux 是 Linus Torvalds 在美國和／或其他國家或地區(qū)的商標(biāo)。
其他公司、產(chǎn)品或服務(wù)名稱可能是其他公司的商標(biāo)或服務(wù)標(biāo)記。
信息都是“按原樣”發(fā)布，沒有任何類型的保證。
所描述的所有的客戶示例只是為了說明那些客戶如何使用 IBM 產(chǎn)品，以及它們可能獲得的結(jié)果。不同客戶所得到的實際環(huán)境代價和性能特性可能會不同。
涉及非 IBM 產(chǎn)品的信息可從這些產(chǎn)品的供應(yīng)商、其出版說明或其他可公開獲得的資料中獲取，并不構(gòu)成 IBM 對此產(chǎn)品的認(rèn)可。非 IBM 價目及性能數(shù)字資源取自可公開獲得的信息，包括供應(yīng)商的聲明和供應(yīng)商的全球主頁。 IBM 沒有對這些產(chǎn)品進行測試，也無法確認(rèn)其性能的精確性、兼容性或任何其他關(guān)于非 IBM 產(chǎn)品的聲明。有關(guān)非 IBM 產(chǎn)品性能的問題應(yīng)當(dāng)向這些產(chǎn)品的供應(yīng)商提出。
所有關(guān)于 IBM 未來方向或意向的聲明都可隨時更改或收回，而不另行通知，它們僅僅表示了目標(biāo)和意愿而已。聯(lián)系您本地的 IBM 辦公人員或者 IBM 授權(quán)的轉(zhuǎn)銷商，以獲得特定的 Statement of General Direction 的全文。
這里所包含的信息可能陳述了預(yù)期的未來功能。上述信息并不打算作為對任何未來產(chǎn)品的特定性能級別、功能或交付時間表的明確承諾。這樣的承諾只會在 IBM 產(chǎn)品中作出。這里出現(xiàn)的信息用于表明 IBM 當(dāng)前的投資和發(fā)展活動，作為一種信任，來幫助我們的客戶規(guī)劃未來。
性能是在受控環(huán)境中使用標(biāo)準(zhǔn)的 IBM 基準(zhǔn)程序測試和估算的。任何用戶實際的吞吐量或性能可能各不相同，這取決于需要考慮的事項，例如用戶作業(yè)流中的多道程序設(shè)計總量、I/O 配置、存儲器配置和處理的工作負(fù)載。因此，我們不能擔(dān)保，個別用戶所獲得的吞吐量或性能改善等同于這里所列的值。
參考資料
作者簡介
|
|
|
|
Nam Keung 是 IBM 的一名高級程序員，他曾致力于 AIX 通信開發(fā)、AIX 多媒體、SOM/DSOM 開發(fā)和 Java 性能方面的工作。他目前的工作包括幫助獨立軟件提供商（Independent Software Vendors，ISV）進行應(yīng)用程序設(shè)計、部署應(yīng)用程序、性能調(diào)優(yōu)和關(guān)于 pSeries 平臺的教育。您可以通過 namkeung@us.ibm.com 與 Nam 聯(lián)系。
|
|
|
|
|
Chakarat Skawratananond 是 IBM eServer Solutions Enablement 組織的一名技術(shù)顧問，在那里，他幫助獨立軟件開發(fā)商在 IBM pSeries 平臺上使用他們的用于 AIX 和 Linux 的應(yīng)用程序。您可以通過 chakarat@us.ibm.com 與 Chakarat 聯(lián)系。
|
|